kontocheck 0.0.6 → 0.0.7
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.
- data/VERSION.yml +1 -1
- data/ext/konto_check_raw/konto_check.c +1713 -379
- data/ext/konto_check_raw/konto_check.h +52 -14
- data/kontocheck.gemspec +54 -0
- metadata +8 -8
data/VERSION.yml
CHANGED
@@ -48,9 +48,9 @@
|
|
48
48
|
|
49
49
|
/* Definitionen und Includes */
|
50
50
|
#ifndef VERSION
|
51
|
-
#define VERSION "
|
51
|
+
#define VERSION "4.0"
|
52
52
|
#endif
|
53
|
-
#define VERSION_DATE "2011-
|
53
|
+
#define VERSION_DATE "2011-07-26"
|
54
54
|
|
55
55
|
#ifndef INCLUDE_KONTO_CHECK_DE
|
56
56
|
#define INCLUDE_KONTO_CHECK_DE 1
|
@@ -122,6 +122,63 @@ static char verbose_debug_buffer[128];
|
|
122
122
|
#define PRINT_VERBOSE_DEBUG_FILE(msg)
|
123
123
|
#endif
|
124
124
|
|
125
|
+
/* Kodierung der Ausgabe und Statusmeldungen (ISO8859-1, CP850, UTF-8, HTML)
|
126
|
+
* encoding gibt die Soll-Kodierung, current_encoding die jeweils aktuelle
|
127
|
+
* Kodierung. current_encoding ist ein- oder zweistellig; die Zehnerstelle
|
128
|
+
* gibt die Kodierung der Statusmeldungen an, die Einerstelle die der
|
129
|
+
* LUT-Blocks. Falls Einer- und Zehnerstelle �bereinstimmen, wird nur die
|
130
|
+
* Einerstelle zur�ckgegeben; falls die LUT-Datei noch nicht initialisiert
|
131
|
+
* wurde, ebenfalls (diese Kodierung wird dann bei der n�chsten
|
132
|
+
* Initialisierung �bernommen). Falls das nicht zutrifft, wird es etwas
|
133
|
+
* kompliziert :-))):
|
134
|
+
*
|
135
|
+
* 1. Falls das Flag keep_raw_data_flag gesetzt ist, werden die Rohdaten der
|
136
|
+
* LUT-Blocks gespeichert; bei einem Wechsel der Kodierung werden die
|
137
|
+
* LUT-Daten ebenfalls umkodiert und current_encoding wird auf den Wert
|
138
|
+
* von encoding gesetzt.
|
139
|
+
*
|
140
|
+
* 2. Falls das Flag keep_raw_data_flag gel�scht ist, werden die Rohdaten
|
141
|
+
* nicht gespeichert (bzw. wenn es gel�scht wird, werden sie wieder
|
142
|
+
* freigegeben), d.h. man kann nicht mehr einfach umkodieren. Nun gibt es
|
143
|
+
* drei M�glichkeiten:
|
144
|
+
*
|
145
|
+
* a) Falls noch nicht initialisiert wurde (oder die Daten wieder
|
146
|
+
* freigegeben wurden), k�nnen bei der n�chsten Initialisierung die
|
147
|
+
* LUT-Blocks konvertiert werden. Daher wird die Kodierung f�r die
|
148
|
+
* LUT-Blocks mit �bernommen.
|
149
|
+
*
|
150
|
+
* b) Falls die alte LUT-Kodierung beibehalten wurde (z.B. Wechsel von 53
|
151
|
+
* nach 3), wird eine einstellige (bzw. beim Umstieg nach 5x eine
|
152
|
+
* zweistellige) Kodierung zur�ckgegeben; in diesem Fall treten keine
|
153
|
+
* Unstimmigkeiten auf.
|
154
|
+
*
|
155
|
+
* c) Die letzte M�glichkeit ist, da� eine neue Kodierung gew�hlt wurde;
|
156
|
+
* in dem Fall wird eine zweistellige Kodierung zur�ckgegeben wie z.B.
|
157
|
+
* 23 (d.h., Statusmeldungen werden mit UTF-8 kodiert, die LUT-Blocks
|
158
|
+
* dagegen mit HTML-Entities). Das Verhalten ist nicht sch�n, aber
|
159
|
+
* unter den gegebenen Randbedingungen nicht zu vermeiden.
|
160
|
+
*
|
161
|
+
* F�r die Speicherung der raw-Daten werden etwa 900K Hauptspeicher
|
162
|
+
* ben�tigt; es ist abzuw�gen, ob man eher den Hauptspeicher ben�tigt oder
|
163
|
+
* den beliebigen Wechsel der Kodierung. Falls der Hauptspeicherbedarf zu
|
164
|
+
* gro� ist, besteht die M�glichkeit den Speicher freizugeben und die
|
165
|
+
* Bibliothek neu zu initialisieren; dabei wird dann auch die neue Kodierung
|
166
|
+
* f�r die LUT-Blocks benutzt (das Vorgehen kostet nat�rlich ziemlig viel
|
167
|
+
* Zeit).
|
168
|
+
*/
|
169
|
+
|
170
|
+
static int encoding=DEFAULT_ENCODING,current_encoding,keep_raw_data_flag=KEEP_RAW_DATA;
|
171
|
+
static char *name_raw,*name_kurz_raw,*name_name_kurz_raw,*ort_raw;
|
172
|
+
static int name_raw_len,name_kurz_raw_len,name_name_kurz_raw_len,ort_raw_len;
|
173
|
+
static char **sortc_buf;
|
174
|
+
static int *sorti_buf;
|
175
|
+
|
176
|
+
/* Funktionspointer auf die aktuelle Kodierung */
|
177
|
+
DLL_EXPORT const char *(*retval_enc)(int)=NULL;
|
178
|
+
|
179
|
+
static int convert_encoding(char **data,UINT4 *len);
|
180
|
+
|
181
|
+
|
125
182
|
/* das Makro RETURN(r) gibt Debug-Meldungen zu Fehler-R�ckgabewerten (zur Fehlersuche) */
|
126
183
|
#if VERBOSE_DEBUG
|
127
184
|
#define RETURN(r) do{if(verbose_debug&2){int rxx; rxx=r; fprintf(stderr,"return %4d [%s] in Zeile %d, Fkt. %s\n",rxx,kto_check_retval2txt_short(rxx),__LINE__,__FUNCTION__); return rxx;} else return r;}while(0)
|
@@ -325,20 +382,22 @@ static char verbose_debug_buffer[128];
|
|
325
382
|
/* globale Variablen +���2 */
|
326
383
|
|
327
384
|
/* einige Variablen zur LUT2-Initialisierung und f�r den LUT-Dump (nur
|
328
|
-
* Beispielssets).
|
329
|
-
*
|
385
|
+
* Beispielssets). Im Kommentar ist angegeben, wieviele Slots (f�r die
|
386
|
+
* Daten + Indizes) f�r das jeweilige Set ben�tigt werden. Die Indexblocks
|
387
|
+
* werden f�r die Blocks Pr�fziffer, Name, Kurzname, PLZ, Ort und BIC
|
388
|
+
* generiert.
|
330
389
|
*/
|
331
390
|
DLL_EXPORT_V int
|
332
|
-
lut_set_0[]={LUT2_BLZ,LUT2_PZ,0}, /* 3 Slots */
|
333
|
-
lut_set_1[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_KURZ,0}, /* 4 Slots */
|
334
|
-
lut_set_2[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_KURZ,LUT2_BIC,0}, /* 5 Slots */
|
335
|
-
lut_set_3[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME,LUT2_PLZ,LUT2_ORT,0}, /* 6 Slots */
|
336
|
-
lut_set_4[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME,LUT2_PLZ,LUT2_ORT,LUT2_BIC,0}, /* 7 Slots */
|
337
|
-
lut_set_5[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,0}, /* 7 Slots */
|
338
|
-
lut_set_6[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,LUT2_NACHFOLGE_BLZ,0}, /* 8 Slots */
|
339
|
-
lut_set_7[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_AENDERUNG,0}, /* 9 Slots */
|
340
|
-
lut_set_8[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_AENDERUNG,LUT2_LOESCHUNG,0}, /* 10 Slots */
|
341
|
-
lut_set_9[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_AENDERUNG,LUT2_LOESCHUNG,LUT2_PAN,LUT2_NR,0}, /* 12 Slots */
|
391
|
+
lut_set_0[]={LUT2_BLZ,LUT2_PZ,0}, /* 3+1 Slots */
|
392
|
+
lut_set_1[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_KURZ,0}, /* 4+2 Slots */
|
393
|
+
lut_set_2[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_KURZ,LUT2_BIC,0}, /* 5+3 Slots */
|
394
|
+
lut_set_3[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME,LUT2_PLZ,LUT2_ORT,0}, /* 6+4 Slots */
|
395
|
+
lut_set_4[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME,LUT2_PLZ,LUT2_ORT,LUT2_BIC,0}, /* 7+5 Slots */
|
396
|
+
lut_set_5[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,0}, /* 7+6 Slots */
|
397
|
+
lut_set_6[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,LUT2_NACHFOLGE_BLZ,0}, /* 8+6 Slots */
|
398
|
+
lut_set_7[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_AENDERUNG,0}, /* 9+6 Slots */
|
399
|
+
lut_set_8[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_AENDERUNG,LUT2_LOESCHUNG,0}, /* 10+6 Slots */
|
400
|
+
lut_set_9[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_AENDERUNG,LUT2_LOESCHUNG,LUT2_PAN,LUT2_NR,0}, /* 12+6 Slots */
|
342
401
|
|
343
402
|
lut_set_o0[]={LUT2_BLZ,LUT2_PZ,0},
|
344
403
|
lut_set_o1[]={LUT2_BLZ,LUT2_PZ,LUT2_NAME_KURZ,0},
|
@@ -409,6 +468,7 @@ static const int tab1[]={0,4,3,2,6},tab2[]={7,1,5,9,8};
|
|
409
468
|
|
410
469
|
/* Inhalt der verschiedenen LUT2-Blocktypen */
|
411
470
|
static const char *lut_block_name1[400],*lut_block_name2[400];
|
471
|
+
static int lut_block_idx[400];
|
412
472
|
|
413
473
|
/* Suchpfad und Defaultnamen f�r LUT-Dateien */
|
414
474
|
static const char *lut_searchpath[]={DEFAULT_LUT_PATH};
|
@@ -420,8 +480,9 @@ static const int lut_name_cnt=sizeof(default_lutname)/sizeof(char *);
|
|
420
480
|
static char *lut2_block_data[400],*current_info;
|
421
481
|
static int lut2_block_status[400],lut2_block_len[400],lut2_cnt,lut2_cnt_hs;
|
422
482
|
static UINT4 current_info_len,current_v1,current_v2;
|
423
|
-
static int lut_id_status,lut_init_level;
|
424
|
-
static char lut_id[36];
|
483
|
+
static int lut_id_status,lut_init_level,current_lut_set,current_lut_level;
|
484
|
+
static char lut_id[36],*current_lutfile;
|
485
|
+
|
425
486
|
|
426
487
|
/* Speicherbereich und Variablen f�r den Default-Buffer */
|
427
488
|
#define INITIAL_DEFAULT_BUFSIZE 4096 /* initiale Buffergr��e (dynamisch) */
|
@@ -474,7 +535,7 @@ static unsigned char ee[500],*eeh,*eep,eec[]={
|
|
474
535
|
/* Arrays f�r die Felder der LUT-Datei u.a. */
|
475
536
|
static char *lut_prolog,*lut_sys_info,*lut_user_info;
|
476
537
|
static char **name,**name_kurz,**ort,*name_data,*name_name_kurz_data,*name_kurz_data,*ort_data,**bic,*bic_buffer,*aenderung,*loeschung;
|
477
|
-
static int lut_version,*blz,*startidx,*plz,*filialen,*pan,*pz_methoden,*bank_nr,*nachfolge_blz;
|
538
|
+
static int lut_version,*blz,*startidx,*plz,*filialen,*pan,*pz_methoden,*bank_nr,*nachfolge_blz,*own_iban,own_iban_cnt;
|
478
539
|
static volatile int init_status,init_in_progress;
|
479
540
|
|
480
541
|
/* Arrays f�r die Suche nach verschiedenen Feldern */
|
@@ -482,7 +543,7 @@ static int *blz_f,*zweigstelle_f,*zweigstelle_f1,*sort_bic,*sort_name,*sort_name
|
|
482
543
|
|
483
544
|
/* Arrays zur Umwandlung von ASCII nach Zahlen */
|
484
545
|
static unsigned int b0[256],b1[256],b2[256],b3[256],b4[256],b5[256],b6[256],b7[256],b8[256],
|
485
|
-
bx1[256],bx2[256],by1[256],by4[256]
|
546
|
+
bx1[256],bx2[256],by1[256],by4[256];
|
486
547
|
|
487
548
|
static short *hash;
|
488
549
|
|
@@ -533,7 +594,7 @@ static int sort_cmp(const void *ap,const void *bp);
|
|
533
594
|
static int create_lutfile_int(char *name, char *prolog, int slots,FILE **lut);
|
534
595
|
static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **data);
|
535
596
|
static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data);
|
536
|
-
static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char *out_buffer,FILE *lut,UINT4 set);
|
597
|
+
static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char *out_buffer,FILE *lut,UINT4 set,int add_idx);
|
537
598
|
static int lut_dir(FILE *lut,int id,UINT4 *slot_cnt,UINT4 *typ,UINT4 *len,
|
538
599
|
UINT4 *compressed_len,UINT4 *adler,int *slot_dir,int *compression);
|
539
600
|
static int lut_index(char *b);
|
@@ -543,17 +604,21 @@ static int lut_multiple_int(int idx,int *cnt,int **p_blz,char ***p_name,char **
|
|
543
604
|
char **p_loeschung,int **p_nachfolge_blz,int *id,int *cnt_all,int **start_idx);
|
544
605
|
static int read_lut(char *filename,int *cnt_blz);
|
545
606
|
static void init_atoi_table(void);
|
546
|
-
static int
|
547
|
-
|
548
|
-
|
549
|
-
|
550
|
-
|
551
|
-
|
607
|
+
static int init_blzf(int *cnt_p);
|
608
|
+
static int suche_str(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,int **blz_base,
|
609
|
+
char ***base_name,int **base_sort,int(*cmp)(const void *, const void *),UINT4 such_idx);
|
610
|
+
static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstelle_base,int **blz_base,
|
611
|
+
int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int cnt,int such_idx);
|
612
|
+
static int suche_int2(int a1,int a2,int *anzahl,int **start_idx,int **zweigstelle_base,int **blz_base,
|
613
|
+
int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int such_idx);
|
552
614
|
static int binary_search(char *a,char **base,int *sort_a,int cnt,int *unten,int *anzahl);
|
553
|
-
static
|
554
|
-
static
|
615
|
+
static int get_sortc(char **a,int enc);
|
616
|
+
static int stri_cmp(char *a,char *b);
|
617
|
+
static int strni_cmp(char *ap,char *bp);
|
555
618
|
static int qcmp_name(const void *ap,const void *bp);
|
556
619
|
static int qcmp_ort(const void *ap,const void *bp);
|
620
|
+
static int qcmp_sortc(const void *ap,const void *bp);
|
621
|
+
static int qcmp_sorti(const void *ap,const void *bp);
|
557
622
|
#if DEBUG>0
|
558
623
|
static int kto_check_int(char *x_blz,int pz_methode,char *kto,int untermethode,RETVAL *retvals);
|
559
624
|
#else
|
@@ -677,21 +742,20 @@ static int sort_cmp(const void *ap,const void *bp)
|
|
677
742
|
return a-b;
|
678
743
|
}
|
679
744
|
|
680
|
-
/* Funktion
|
745
|
+
/* Funktion cmp_int() +���1 */
|
681
746
|
/* ###########################################################################
|
682
|
-
* # Diese Funktion dient
|
683
|
-
* #
|
747
|
+
* # Diese Funktion dient als Vergleichsfunktion f�r zwei Integerwerte f�r #
|
748
|
+
* # die Quicksort-Bibliotheksfunktion. #
|
684
749
|
* # #
|
685
750
|
* # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
|
686
751
|
* ###########################################################################
|
687
752
|
*/
|
688
753
|
|
689
|
-
static int
|
754
|
+
static int cmp_int(const void *a,const void *b)
|
690
755
|
{
|
691
|
-
return *(
|
756
|
+
return *(int*)a-*(int*)b;
|
692
757
|
}
|
693
758
|
|
694
|
-
|
695
759
|
/*
|
696
760
|
* ##########################################################################
|
697
761
|
* # set_default_compression(): Kompressionsmethode f�r die LUT-Dateien #
|
@@ -1443,49 +1507,71 @@ static int lut_dir(FILE *lut,int id,UINT4 *slot_cnt,UINT4 *typ,UINT4 *len,
|
|
1443
1507
|
* ###########################################################################
|
1444
1508
|
*/
|
1445
1509
|
|
1446
|
-
static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char *out_buffer,
|
1510
|
+
static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char *out_buffer,
|
1511
|
+
FILE *lut,UINT4 set,int add_idx)
|
1447
1512
|
{
|
1448
|
-
char *ptr,*zptr,*dptr,*name_hauptstelle=NULL,*name_start=NULL;
|
1449
|
-
int cnt,i,j,max,b,prev_blz,diff,hs,retval;
|
1513
|
+
char *ptr,*zptr,*dptr,*name_hauptstelle=NULL,*name_start=NULL,*data,*data_idx,**sortc_buf1,**sortc_buf2;
|
1514
|
+
int cnt,i,j,k,max,b,prev_blz,diff,hs,retval,*iptr;
|
1450
1515
|
|
1451
1516
|
if(set==2)typ+=SET_OFFSET; /* sekund�res Set schreiben */
|
1517
|
+
|
1518
|
+
/* in out_buffer steht ein buffer f�r die Ausgabesachen bereit. Er ist so
|
1519
|
+
* gro� wie die BLZ-Datei der Bundesbank, hat also gen�gend Luft f�r alle
|
1520
|
+
* Blocks im Klartext sowie noch zus�tzlich die Index-Arrays und die
|
1521
|
+
* Pointer auf die String-Daten. Diese beiden Arrays werden am Beginn von
|
1522
|
+
* out_buffer plaziert, da sie eine feste Gr��e haben; danach kommt der
|
1523
|
+
* Buffer data f�r die Blockdaten (Rohwerte) sowie data_idx (sp�ter, erst
|
1524
|
+
* bei der Index-Generierung) f�r die Indexdaten.
|
1525
|
+
*/
|
1526
|
+
iptr=(int*)out_buffer;
|
1527
|
+
sortc_buf1=(char**)(iptr+(bank_cnt+10));
|
1528
|
+
sorti_buf=(int*)sortc_buf1;
|
1529
|
+
sortc_buf2=(char**)(sortc_buf1+(bank_cnt+10));
|
1530
|
+
data=(char*)(sortc_buf2+(bank_cnt+10));
|
1531
|
+
|
1452
1532
|
switch(typ){
|
1453
1533
|
case LUT2_BLZ: /* Bankleitzahl */
|
1454
1534
|
case LUT2_2_BLZ:
|
1455
1535
|
/* die Anzahl der Hauptstellen wird erst nach der Schleife
|
1456
1536
|
* eingetragen, da sie hier noch nicht bekannt ist. Die Ausgabe
|
1457
|
-
* beginnt daher erst bei
|
1537
|
+
* beginnt daher erst bei data+4.
|
1538
|
+
*
|
1539
|
+
* Die innere Struktur des BLZ-Blocks entspricht dem der
|
1540
|
+
* Lut-Versionen 1.0/1.1, allerdings wird der Block noch
|
1541
|
+
* komprimiert und dadurch etwas kleiner. Die Bankleitzahlen sind
|
1542
|
+
* sortiert und innerhalb derselben BLZ so angeordnet, da� jeweils
|
1543
|
+
* die Hauptstelle als erste erscheint.
|
1458
1544
|
*/
|
1459
|
-
for(i=cnt=prev_blz=0,dptr=
|
1545
|
+
for(i=cnt=prev_blz=0,dptr=data+4;i<bank_cnt;i++){
|
1460
1546
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1461
1547
|
b=qs_blz[qs_sortidx[i]];
|
1462
1548
|
diff=b-prev_blz;
|
1463
1549
|
prev_blz=b;
|
1464
|
-
if(diff==0)
|
1550
|
+
if(diff==0) /* gleiche Bank (Zweigstelle), kein Eintrag */
|
1465
1551
|
continue;
|
1466
1552
|
else if(diff>0 && diff<=253){
|
1467
1553
|
*dptr++=diff&255;
|
1468
1554
|
}
|
1469
|
-
else if(diff>253 && diff<65536){ /* 2 Byte */
|
1555
|
+
else if(diff>253 && diff<65536){ /* 2 Byte, Kennmarker 254 */
|
1470
1556
|
*dptr++=254;
|
1471
1557
|
UI2C(diff,dptr);
|
1472
1558
|
}
|
1473
|
-
else if(diff>65535){ /* Wert direkt eintragen */
|
1559
|
+
else if(diff>65535){ /* Wert direkt eintragen, Kennmarker 255 */
|
1474
1560
|
*dptr++=255;
|
1475
1561
|
UL2C(b,dptr);
|
1476
1562
|
}
|
1477
1563
|
cnt++;
|
1478
1564
|
}
|
1479
|
-
ptr=
|
1565
|
+
ptr=data;
|
1480
1566
|
UI2C(cnt,ptr); /* Anzahl Hauptstellen an den Anfang schreiben */
|
1481
1567
|
UI2C(bank_cnt,ptr); /* Anzahl Datens�tze (mit Nebenstellen) */
|
1482
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1568
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1483
1569
|
break;
|
1484
1570
|
|
1485
1571
|
case LUT2_FILIALEN: /* Anzahl Filialen */
|
1486
1572
|
case LUT2_2_FILIALEN:
|
1487
1573
|
if(auch_filialen){
|
1488
|
-
for(i=max=1,cnt=1,j=10000000,dptr=
|
1574
|
+
for(i=max=1,cnt=1,j=10000000,dptr=data;i<bank_cnt;i++){
|
1489
1575
|
if(j==qs_blz[qs_sortidx[i]])
|
1490
1576
|
cnt++;
|
1491
1577
|
else{
|
@@ -1500,48 +1586,61 @@ static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char
|
|
1500
1586
|
fprintf(stderr,"maximale Anzahl bei Filialen: %d\n",max);
|
1501
1587
|
if(cnt>255)fprintf(stderr,"Fehler in LUT-Datei wegen Maximalzahl>255!!\n");
|
1502
1588
|
}
|
1503
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1589
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1504
1590
|
}
|
1505
1591
|
break;
|
1506
1592
|
|
1507
1593
|
case LUT2_NAME: /* Bezeichnung des Kreditinstitutes (ohne Rechtsform) */
|
1508
1594
|
case LUT2_2_NAME:
|
1509
|
-
for(i=0,name_hauptstelle=name_start=(char*)"",dptr=
|
1510
|
-
|
1511
|
-
|
1512
|
-
|
1513
|
-
|
1514
|
-
|
1515
|
-
|
1516
|
-
|
1517
|
-
|
1518
|
-
|
1519
|
-
|
1520
|
-
|
1521
|
-
|
1522
|
-
|
1523
|
-
*dptr++=0;
|
1524
|
-
/* falls der Name einer Nebenstelle dem der Hauptstelle entspricht, nur ein Nullbyte eintragen */
|
1525
|
-
if(hs=='2' && !strcmp(name_hauptstelle,name_start)){
|
1526
|
-
dptr=name_start;
|
1595
|
+
for(i=j=0,name_hauptstelle=name_start=(char*)"",dptr=data;i<bank_cnt;i++)
|
1596
|
+
if((hs=qs_hauptstelle[qs_sortidx[i]])=='1' || auch_filialen){
|
1597
|
+
zptr=qs_zeilen[qs_sortidx[i]];
|
1598
|
+
if(hs=='1' && auch_filialen){
|
1599
|
+
*dptr++=1; /* Markierung f�r Hauptstelle, kann im Text nicht vorkommen */
|
1600
|
+
sortc_buf1[j]=name_hauptstelle=dptr;
|
1601
|
+
}
|
1602
|
+
else
|
1603
|
+
sortc_buf1[j]=name_start=dptr;
|
1604
|
+
for(ptr=zptr+9;ptr<zptr+67;)*dptr++=*ptr++;
|
1605
|
+
if(*(dptr-1)==' '){
|
1606
|
+
for(dptr--;*dptr==' ';)dptr--;
|
1607
|
+
dptr++; /* das letzte Byte war kein Blank mehr */
|
1608
|
+
}
|
1527
1609
|
*dptr++=0;
|
1610
|
+
/* falls der Name einer Nebenstelle dem der Hauptstelle entspricht, nur ein Nullbyte eintragen */
|
1611
|
+
if(hs=='2' && !strcmp(name_hauptstelle,name_start)){
|
1612
|
+
dptr=name_start;
|
1613
|
+
*dptr++=0;
|
1614
|
+
sortc_buf1[j]=name_hauptstelle;
|
1615
|
+
}
|
1616
|
+
j++;
|
1528
1617
|
}
|
1618
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1619
|
+
|
1620
|
+
/* Index-Block f�r Namen generieren */
|
1621
|
+
if(add_idx){
|
1622
|
+
data_idx=dptr;
|
1623
|
+
sortc_buf=sortc_buf1;
|
1624
|
+
for(i=0;i<j;i++)iptr[i]=i; /* Index-Array initialisieren */
|
1625
|
+
qsort(iptr,j,sizeof(int),qcmp_sortc);
|
1626
|
+
UI2C(j,dptr);
|
1627
|
+
for(i=0;i<j;i++)UI2C(iptr[i],dptr);
|
1628
|
+
CHECK_RETURN(write_lut_block_int(lut,LUT2_NAME_SORT+(typ-LUT2_NAME),dptr-data_idx,data_idx));
|
1529
1629
|
}
|
1530
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-out_buffer,out_buffer));
|
1531
1630
|
break;
|
1532
1631
|
|
1533
1632
|
case LUT2_NAME_NAME_KURZ: /* Name und Kurzname zusammen => besser (72212 Byte kompr. gegen�ber 85285 bei getrennt) */
|
1534
1633
|
case LUT2_2_NAME_NAME_KURZ:
|
1535
|
-
for(i=0,dptr=
|
1536
|
-
hs=qs_hauptstelle[qs_sortidx[i]];
|
1634
|
+
for(i=j=0,dptr=data;i<bank_cnt;i++)if((hs=qs_hauptstelle[qs_sortidx[i]])=='1' || auch_filialen){
|
1537
1635
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1636
|
+
|
1538
1637
|
/* Bankname */
|
1539
1638
|
if(hs=='1' && auch_filialen){
|
1540
1639
|
*dptr++=1; /* Markierung f�r Hauptstelle, kann im Text nicht vorkommen */
|
1541
|
-
name_hauptstelle=dptr;
|
1640
|
+
sortc_buf1[j]=name_hauptstelle=dptr;
|
1542
1641
|
}
|
1543
1642
|
else
|
1544
|
-
name_start=dptr;
|
1643
|
+
sortc_buf1[j]=name_start=dptr;
|
1545
1644
|
for(ptr=zptr+9;ptr<zptr+67;)*dptr++=*ptr++;
|
1546
1645
|
if(*(dptr-1)==' '){
|
1547
1646
|
for(dptr--;*dptr==' ';)dptr--;
|
@@ -1552,72 +1651,130 @@ static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char
|
|
1552
1651
|
if(hs=='2' && !strcmp(name_hauptstelle,name_start)){
|
1553
1652
|
dptr=name_start;
|
1554
1653
|
*dptr++=0;
|
1654
|
+
sortc_buf1[j]=name_hauptstelle;
|
1555
1655
|
}
|
1656
|
+
|
1556
1657
|
/* Kurzbezeichnung */
|
1557
|
-
for(ptr=zptr+107;ptr<zptr+134;)*dptr++=*ptr++;
|
1658
|
+
for(ptr=zptr+107,sortc_buf2[j]=dptr;ptr<zptr+134;)*dptr++=*ptr++;
|
1558
1659
|
if(*(dptr-1)==' '){
|
1559
1660
|
for(dptr--;*dptr==' ';)dptr--;
|
1560
1661
|
dptr++; /* das letzte Byte war kein Blank mehr */
|
1561
1662
|
}
|
1562
1663
|
*dptr++=0;
|
1664
|
+
j++;
|
1665
|
+
}
|
1666
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1667
|
+
|
1668
|
+
/* Index-Block f�r Namen und Kurznamen generieren */
|
1669
|
+
if(add_idx){
|
1670
|
+
data_idx=dptr;
|
1671
|
+
sortc_buf=sortc_buf1; /* Namen */
|
1672
|
+
for(i=0;i<j;i++)iptr[i]=i; /* Index-Array initialisieren */
|
1673
|
+
qsort(iptr,j,sizeof(int),qcmp_sortc);
|
1674
|
+
UI2C(j,dptr);
|
1675
|
+
for(i=0;i<j;i++)UI2C(iptr[i],dptr);
|
1676
|
+
CHECK_RETURN(write_lut_block_int(lut,LUT2_NAME_SORT+(typ-LUT2_NAME_NAME_KURZ),dptr-data_idx,data_idx));
|
1677
|
+
|
1678
|
+
/* Index-Block f�r Kurznamen generieren */
|
1679
|
+
sortc_buf=sortc_buf2; /* Kurznamen */
|
1680
|
+
for(i=0;i<j;i++)iptr[i]=i; /* Index-Array initialisieren */
|
1681
|
+
qsort(iptr,j,sizeof(int),qcmp_sortc);
|
1682
|
+
dptr=data_idx;
|
1683
|
+
UI2C(j,dptr);
|
1684
|
+
for(i=0;i<j;i++)UI2C(iptr[i],dptr);
|
1685
|
+
CHECK_RETURN(write_lut_block_int(lut,LUT2_NAME_KURZ_SORT+(typ-LUT2_NAME_NAME_KURZ),dptr-data_idx,data_idx));
|
1563
1686
|
}
|
1564
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-out_buffer,out_buffer));
|
1565
1687
|
break;
|
1566
1688
|
|
1567
1689
|
case LUT2_PLZ: /* Postleitzahl */
|
1568
1690
|
case LUT2_2_PLZ:
|
1569
|
-
for(i=0,dptr=
|
1691
|
+
for(i=j=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1570
1692
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1571
|
-
|
1572
|
-
UM2C(
|
1693
|
+
k=Z(b5,67)+Z(b4,68)+Z(b3,69)+Z(b2,70)+Z(b1,71);
|
1694
|
+
UM2C(k,dptr);
|
1695
|
+
sorti_buf[j++]=k;
|
1696
|
+
}
|
1697
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1698
|
+
|
1699
|
+
/* Index-Block f�r PLZ generieren */
|
1700
|
+
if(add_idx){
|
1701
|
+
data_idx=dptr;
|
1702
|
+
for(i=0;i<j;i++)iptr[i]=i; /* Index-Array initialisieren */
|
1703
|
+
qsort(iptr,j,sizeof(int),qcmp_sorti);
|
1704
|
+
UI2C(j,dptr);
|
1705
|
+
for(i=0;i<j;i++)UI2C(iptr[i],dptr);
|
1706
|
+
CHECK_RETURN(write_lut_block_int(lut,LUT2_PLZ_SORT+(typ-LUT2_PLZ),dptr-data_idx,data_idx));
|
1573
1707
|
}
|
1574
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-out_buffer,out_buffer));
|
1575
1708
|
break;
|
1576
1709
|
|
1577
1710
|
case LUT2_ORT: /* Ort */
|
1578
1711
|
case LUT2_2_ORT:
|
1579
|
-
for(i=0,dptr=
|
1712
|
+
for(i=j=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1580
1713
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1581
|
-
for(ptr=zptr+72;ptr<zptr+107;)*dptr++=*ptr++;
|
1714
|
+
for(ptr=zptr+72,sortc_buf1[j]=dptr;ptr<zptr+107;)*dptr++=*ptr++;
|
1582
1715
|
if(*(dptr-1)==' '){
|
1583
1716
|
for(dptr--;*dptr==' ';)dptr--;
|
1584
1717
|
dptr++; /* das letzte Byte war kein Blank mehr */
|
1585
1718
|
}
|
1586
1719
|
*dptr++=0;
|
1720
|
+
j++;
|
1721
|
+
}
|
1722
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1723
|
+
|
1724
|
+
/* Index-Block f�r Ort generieren */
|
1725
|
+
if(add_idx){
|
1726
|
+
data_idx=dptr;
|
1727
|
+
sortc_buf=sortc_buf1;
|
1728
|
+
for(i=0;i<j;i++)iptr[i]=i; /* Index-Array initialisieren */
|
1729
|
+
qsort(iptr,j,sizeof(int),qcmp_sortc);
|
1730
|
+
UI2C(j,dptr);
|
1731
|
+
for(i=0;i<j;i++)UI2C(iptr[i],dptr);
|
1732
|
+
CHECK_RETURN(write_lut_block_int(lut,LUT2_ORT_SORT+(typ-LUT2_ORT),dptr-data_idx,data_idx));
|
1587
1733
|
}
|
1588
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-out_buffer,out_buffer));
|
1589
1734
|
break;
|
1590
1735
|
|
1591
1736
|
case LUT2_NAME_KURZ: /* Kurzbezeichnung des Kreditinstitutes mit Ort (ohne Rechtsform) */
|
1592
1737
|
case LUT2_2_NAME_KURZ:
|
1593
|
-
for(i=0,dptr=
|
1738
|
+
for(i=j=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1594
1739
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1595
|
-
for(ptr=zptr+107;ptr<zptr+134;)*dptr++=*ptr++;
|
1740
|
+
for(ptr=zptr+107,sortc_buf1[j]=dptr;ptr<zptr+134;)*dptr++=*ptr++;
|
1596
1741
|
if(*(dptr-1)==' '){
|
1597
1742
|
for(dptr--;*dptr==' ';)dptr--;
|
1598
1743
|
dptr++; /* das letzte Byte war kein Blank mehr */
|
1599
1744
|
}
|
1600
1745
|
*dptr++=0;
|
1746
|
+
j++;
|
1747
|
+
}
|
1748
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1749
|
+
|
1750
|
+
/* Index-Block f�r Kurznamen generieren */
|
1751
|
+
if(add_idx){
|
1752
|
+
data_idx=dptr;
|
1753
|
+
sortc_buf=sortc_buf1;
|
1754
|
+
for(i=0;i<j;i++)iptr[i]=i; /* Index-Array initialisieren */
|
1755
|
+
qsort(iptr,j,sizeof(int),qcmp_sortc);
|
1756
|
+
UI2C(j,dptr);
|
1757
|
+
for(i=0;i<j;i++)UI2C(iptr[i],dptr);
|
1758
|
+
CHECK_RETURN(write_lut_block_int(lut,LUT2_NAME_KURZ_SORT+(typ-LUT2_NAME_KURZ),dptr-data_idx,data_idx));
|
1601
1759
|
}
|
1602
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-out_buffer,out_buffer));
|
1603
1760
|
break;
|
1604
1761
|
|
1605
1762
|
case LUT2_PAN: /* Institutsnummer f�r PAN */
|
1606
1763
|
case LUT2_2_PAN:
|
1607
|
-
for(i=0,dptr=
|
1764
|
+
for(i=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1608
1765
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1609
1766
|
if(*(zptr+134)==' ' && *(zptr+135)==' ' && *(zptr+136)==' ' && *(zptr+137)==' ' && *(zptr+138)==' ')
|
1610
|
-
|
1767
|
+
k=0;
|
1611
1768
|
else
|
1612
|
-
|
1613
|
-
UM2C(
|
1769
|
+
k=Z(b5,134)+Z(b4,135)+Z(b3,136)+Z(b2,137)+Z(b1,138);
|
1770
|
+
UM2C(k,dptr);
|
1614
1771
|
}
|
1615
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1772
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1616
1773
|
break;
|
1617
1774
|
|
1618
1775
|
case LUT2_BIC: /* Bank Identifier Code - BIC */
|
1619
1776
|
case LUT2_2_BIC:
|
1620
|
-
for(i=0,dptr=
|
1777
|
+
for(i=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1621
1778
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1622
1779
|
|
1623
1780
|
/* BIC mit DE an Stellen 5 und 6 (normal): die beiden Stellen weglassen */
|
@@ -1647,57 +1804,87 @@ static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char
|
|
1647
1804
|
else
|
1648
1805
|
*dptr++=0;
|
1649
1806
|
}
|
1650
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1807
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1808
|
+
|
1809
|
+
/* Index-Block f�r BIC generieren. Die BICs werden noch einmal neu
|
1810
|
+
* eingelesen, da sich die obige Version sich zum Sortieren eignet.
|
1811
|
+
*/
|
1812
|
+
if(add_idx){
|
1813
|
+
for(i=j=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1814
|
+
zptr=qs_zeilen[qs_sortidx[i]];
|
1815
|
+
sortc_buf1[j++]=dptr;
|
1816
|
+
if(*(zptr+139)!=' ')for(ptr=zptr+139;ptr<zptr+150;)*dptr++=*ptr++;
|
1817
|
+
*dptr++=0;
|
1818
|
+
}
|
1819
|
+
data_idx=dptr;
|
1820
|
+
sortc_buf=sortc_buf1;
|
1821
|
+
for(i=0;i<j;i++)iptr[i]=i; /* Index-Array initialisieren */
|
1822
|
+
qsort(iptr,j,sizeof(int),qcmp_sortc);
|
1823
|
+
UI2C(j,dptr);
|
1824
|
+
for(i=0;i<j;i++)UI2C(iptr[i],dptr);
|
1825
|
+
CHECK_RETURN(write_lut_block_int(lut,LUT2_BIC_SORT+(typ-LUT2_BIC),dptr-data_idx,data_idx));
|
1826
|
+
}
|
1651
1827
|
break;
|
1652
1828
|
|
1653
1829
|
case LUT2_PZ: /* Kennzeichen f�r Pr�fzifferberechnungsmethode */
|
1654
1830
|
case LUT2_2_PZ:
|
1655
1831
|
/* Pr�fziffermethoden nur f�r die Hauptstellen und Testbanken */
|
1656
|
-
for(i=0,dptr=
|
1832
|
+
for(i=j=0,dptr=data;i<bank_cnt;i++){
|
1657
1833
|
if(qs_hauptstelle[qs_sortidx[i]]=='1' || qs_hauptstelle[qs_sortidx[i]]=='3'){
|
1658
1834
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1659
|
-
*dptr++=bx2[(int)*(zptr+150)]+bx1[(int)*(zptr+151)];
|
1835
|
+
*dptr++=k=bx2[(int)*(zptr+150)]+bx1[(int)*(zptr+151)];
|
1836
|
+
sorti_buf[j++]=k;
|
1660
1837
|
}
|
1661
1838
|
}
|
1662
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1839
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1840
|
+
|
1841
|
+
/* Index-Block f�r PZ generieren und schreiben */
|
1842
|
+
if(add_idx){
|
1843
|
+
data_idx=dptr;
|
1844
|
+
for(i=0;i<j;i++)iptr[i]=i; /* Index-Array initialisieren */
|
1845
|
+
qsort(iptr,j,sizeof(int),qcmp_sorti);
|
1846
|
+
UI2C(j,dptr);
|
1847
|
+
for(i=0;i<j;i++)UI2C(iptr[i],dptr);
|
1848
|
+
CHECK_RETURN(write_lut_block_int(lut,LUT2_PZ_SORT+(typ-LUT2_PZ),dptr-data_idx,data_idx));
|
1849
|
+
}
|
1663
1850
|
break;
|
1664
1851
|
|
1665
1852
|
case LUT2_NR: /* Nummer des Datensatzes */
|
1666
1853
|
case LUT2_2_NR:
|
1667
|
-
for(i=0,dptr=
|
1854
|
+
for(i=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1668
1855
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1669
1856
|
j=Z(b6,152)+Z(b5,153)+Z(b4,154)+Z(b3,155)+Z(b2,156)+Z(b1,157);
|
1670
1857
|
UM2C(j,dptr);
|
1671
1858
|
}
|
1672
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1859
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1673
1860
|
break;
|
1674
1861
|
|
1675
1862
|
case LUT2_AENDERUNG: /* �nderungskennzeichen */
|
1676
1863
|
case LUT2_2_AENDERUNG:
|
1677
|
-
for(i=0,dptr=
|
1864
|
+
for(i=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1678
1865
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1679
1866
|
*dptr++=*(zptr+158);
|
1680
1867
|
}
|
1681
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1868
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1682
1869
|
break;
|
1683
1870
|
|
1684
1871
|
case LUT2_LOESCHUNG: /* Hinweis auf eine beabsichtigte Bankleitzahll�schung */
|
1685
1872
|
case LUT2_2_LOESCHUNG:
|
1686
|
-
for(i=0,dptr=
|
1873
|
+
for(i=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1687
1874
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1688
1875
|
*dptr++=*(zptr+159);
|
1689
1876
|
}
|
1690
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1877
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1691
1878
|
break;
|
1692
1879
|
|
1693
1880
|
case LUT2_NACHFOLGE_BLZ: /* Hinweis auf Nachfolge-Bankleitzahl */
|
1694
1881
|
case LUT2_2_NACHFOLGE_BLZ:
|
1695
|
-
for(i=0,dptr=
|
1882
|
+
for(i=0,dptr=data;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
|
1696
1883
|
zptr=qs_zeilen[qs_sortidx[i]];
|
1697
1884
|
j=Z(b8,160)+Z(b7,161)+Z(b6,162)+Z(b5,163)+Z(b4,164)+Z(b3,165)+Z(b2,166)+Z(b1,167);
|
1698
1885
|
UL2C(j,dptr);
|
1699
1886
|
}
|
1700
|
-
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-
|
1887
|
+
CHECK_RETURN(write_lut_block_int(lut,typ,dptr-data,data));
|
1701
1888
|
break;
|
1702
1889
|
}
|
1703
1890
|
return OK;
|
@@ -1724,7 +1911,7 @@ DLL_EXPORT int generate_lut2_p(char *inputname,char *outputname,char *user_info,
|
|
1724
1911
|
int i,j;
|
1725
1912
|
UINT4 *felder1,felder2[MAX_SLOTS+1];
|
1726
1913
|
|
1727
|
-
/* Es werden defaultm��ig mindestens
|
1914
|
+
/* Es werden defaultm��ig mindestens 40 Slots angelegt. Die Slots brauchen nicht viel
|
1728
1915
|
* Speicher (12 Byte/Slot), aber das Slotdirectory l��t sich nachtr�glich nicht mehr
|
1729
1916
|
* vergr��ern. Falls die Datei mit zu wenigen Slots angelegt ist, k�nnen u.U. keine
|
1730
1917
|
* Blocks mehr eingef�gt werden.
|
@@ -1733,17 +1920,17 @@ DLL_EXPORT int generate_lut2_p(char *inputname,char *outputname,char *user_info,
|
|
1733
1920
|
*/
|
1734
1921
|
|
1735
1922
|
switch(felder){
|
1736
|
-
case 0: felder1=(UINT4 *)lut_set_0; if(!slots)slots=
|
1737
|
-
case 1: felder1=(UINT4 *)lut_set_1; if(!slots)slots=
|
1738
|
-
case 2: felder1=(UINT4 *)lut_set_2; if(!slots)slots=
|
1739
|
-
case 3: felder1=(UINT4 *)lut_set_3; if(!slots)slots=
|
1740
|
-
case 4: felder1=(UINT4 *)lut_set_4; if(!slots)slots=
|
1741
|
-
case 5: felder1=(UINT4 *)lut_set_5; if(!slots)slots=
|
1742
|
-
case 6: felder1=(UINT4 *)lut_set_6; if(!slots)slots=
|
1743
|
-
case 7: felder1=(UINT4 *)lut_set_7; if(!slots)slots=
|
1744
|
-
case 8: felder1=(UINT4 *)lut_set_8; if(!slots)slots=
|
1745
|
-
case 9: felder1=(UINT4 *)lut_set_9; if(!slots)slots=
|
1746
|
-
default: felder1=(UINT4 *)lut_set_9; if(!slots)slots=
|
1923
|
+
case 0: felder1=(UINT4 *)lut_set_0; if(!slots)slots=40; break; /* 5 Slots/Satz */
|
1924
|
+
case 1: felder1=(UINT4 *)lut_set_1; if(!slots)slots=40; break; /* 7 Slots/Satz */
|
1925
|
+
case 2: felder1=(UINT4 *)lut_set_2; if(!slots)slots=40; break; /* 9 Slots/Satz */
|
1926
|
+
case 3: felder1=(UINT4 *)lut_set_3; if(!slots)slots=45; break; /* 11 Slots/Satz */
|
1927
|
+
case 4: felder1=(UINT4 *)lut_set_4; if(!slots)slots=45; break; /* 13 Slots/Satz */
|
1928
|
+
case 5: felder1=(UINT4 *)lut_set_5; if(!slots)slots=45; break; /* 14 Slots/Satz */
|
1929
|
+
case 6: felder1=(UINT4 *)lut_set_6; if(!slots)slots=50; break; /* 15 Slots/Satz */
|
1930
|
+
case 7: felder1=(UINT4 *)lut_set_7; if(!slots)slots=50; break; /* 16 Slots/Satz */
|
1931
|
+
case 8: felder1=(UINT4 *)lut_set_8; if(!slots)slots=50; break; /* 17 Slots/Satz */
|
1932
|
+
case 9: felder1=(UINT4 *)lut_set_9; if(!slots)slots=50; break; /* 19 Slots/Satz */
|
1933
|
+
default: felder1=(UINT4 *)lut_set_9; if(!slots)slots=50; break; /* 19 Slots/Satz */
|
1747
1934
|
}
|
1748
1935
|
i=0;
|
1749
1936
|
felder2[i++]=LUT2_BLZ;
|
@@ -1776,12 +1963,19 @@ DLL_EXPORT int generate_lut2(char *inputname,char *outputname,const char *user_i
|
|
1776
1963
|
char *buffer,*out_buffer,*ptr,*zptr,*dptr;
|
1777
1964
|
const char *testbanken;
|
1778
1965
|
UINT4 bufsize,adler,g1,g2;
|
1779
|
-
int cnt,bank_cnt,i,j,retval,h,auch_filialen,prev_blz,b,diff,ok;
|
1966
|
+
int cnt,bank_cnt,i,j,retval,h,auch_filialen,prev_blz,b,diff,ok,add_idx,felder_fertig[LAST_LUT_BLOCK+1];
|
1780
1967
|
struct stat s_buf;
|
1781
1968
|
FILE *in,*lut;
|
1782
1969
|
time_t t;
|
1783
1970
|
struct tm timebuf,*timeptr;
|
1784
1971
|
|
1972
|
+
if(set<10)
|
1973
|
+
add_idx=1;
|
1974
|
+
else{
|
1975
|
+
set-=10;
|
1976
|
+
add_idx=0;
|
1977
|
+
}
|
1978
|
+
for(i=0;i<LAST_LUT_BLOCK;i++)felder_fertig[i]=0;
|
1785
1979
|
lut=NULL;
|
1786
1980
|
ok=OK;
|
1787
1981
|
if(!gueltigkeit || !*gueltigkeit){
|
@@ -1808,10 +2002,10 @@ DLL_EXPORT int generate_lut2(char *inputname,char *outputname,const char *user_i
|
|
1808
2002
|
* Platz geschoben.
|
1809
2003
|
*/
|
1810
2004
|
testbanken=
|
1811
|
-
"130511721Testbank Verfahren 52
|
1812
|
-
"160520721Testbank Verfahren 53
|
1813
|
-
"800537721Testbank Verfahren B6
|
1814
|
-
"800537821Testbank Verfahren B6
|
2005
|
+
"130511721Testbank Verfahren 52 57368Elsperhusen Testbank 52 Elsperhusen 13145TESTDEX987652130000U000000000\n"
|
2006
|
+
"160520721Testbank Verfahren 53 57368Elsperhusen Testbank 53 Elsperhusen 13145TESTDEX987653130000U000000000\n"
|
2007
|
+
"800537721Testbank Verfahren B6 57368Elsperhusen Testbank B6 Elsperhusen 13145TESTDEX9876B6130000U000000000\n"
|
2008
|
+
"800537821Testbank Verfahren B6 57368Elsperhusen Testbank B6 Elsperhusen 13145TESTDEX9876B6130000U000000000\n";
|
1815
2009
|
if(!init_status&1)init_atoi_table();
|
1816
2010
|
if(!felder)felder=(UINT4 *)DEFAULT_LUT_FIELDS;
|
1817
2011
|
if(!lut_version)lut_version=DEFAULT_LUT_VERSION;
|
@@ -2007,15 +2201,16 @@ DLL_EXPORT int generate_lut2(char *inputname,char *outputname,const char *user_i
|
|
2007
2201
|
goto fini;
|
2008
2202
|
}
|
2009
2203
|
|
2010
|
-
sprintf(out_buffer,"
|
2011
|
-
g1,g2,set<2?"
|
2204
|
+
sprintf(out_buffer,"Gueltigkeit der Daten: %08u-%08u (%s Datensatz)\nEnthaltene Felder:",
|
2205
|
+
g1,g2,set<2?"Erster":"Zweiter");
|
2012
2206
|
for(i=0,ptr=out_buffer;felder[i];i++){
|
2013
2207
|
/* testen, ob ein ung�ltiges Feld angegeben wurde */
|
2014
|
-
if(felder[i]<1 || felder[i]>LAST_LUT_BLOCK)continue;
|
2208
|
+
if(felder[i]<1 || felder[i]>LAST_LUT_BLOCK || felder_fertig[felder[i]])continue;
|
2209
|
+
felder_fertig[felder[i]]=1;
|
2015
2210
|
while(*ptr)ptr++;
|
2016
2211
|
if(i>0)*ptr++=',';
|
2017
2212
|
*ptr++=' ';
|
2018
|
-
sprintf(ptr,"%s",lut_block_name1[felder[i]]);
|
2213
|
+
sprintf(ptr,"%s%s",lut_block_name1[felder[i]],add_idx && lut_block_idx[felder[i]]?"+":"");
|
2019
2214
|
}
|
2020
2215
|
while(*ptr)ptr++;
|
2021
2216
|
*ptr++='\n';
|
@@ -2031,13 +2226,14 @@ DLL_EXPORT int generate_lut2(char *inputname,char *outputname,const char *user_i
|
|
2031
2226
|
*/
|
2032
2227
|
srand(time(NULL)+getpid()); /* Zufallszahlengenerator initialisieren */
|
2033
2228
|
sprintf(ptr,"BLZ Lookup Table/Format 2.0\nLUT-Datei generiert am %d.%d.%d, %d:%02d aus %s%s%s\n"
|
2034
|
-
"Anzahl Banken: %d, davon Hauptstellen: %d (inkl. %d Testbanken)\
|
2035
|
-
"
|
2036
|
-
"
|
2229
|
+
"Anzahl Banken: %d, davon Hauptstellen: %d (inkl. %d Testbanken)\n"
|
2230
|
+
"dieser Datensatz enthaelt %s, %s\n"
|
2231
|
+
"Kompression: %s\nDatei-ID (zufaellig, fuer inkrementelle Initialisierung):\n"
|
2037
2232
|
"%04x%04x%04x%04x%04x%04x%04x%04x\n",
|
2038
2233
|
timeptr->tm_mday,timeptr->tm_mon+1,timeptr->tm_year+1900,timeptr->tm_hour,
|
2039
2234
|
timeptr->tm_min,inputname,*user_info?"\\\n":"",user_info,
|
2040
2235
|
bank_cnt,h,(int)strlen(testbanken)/168,auch_filialen?"auch die Filialen":"nur die Hauptstellen",
|
2236
|
+
add_idx?"sowie Indexblocks":"keine Indexblocks",
|
2041
2237
|
compr_str[compression_lib],
|
2042
2238
|
rand()&32767,rand()&32767,rand()&32767,rand()&32767,rand()&32767,rand()&32767,rand()&32767,rand()&32767);
|
2043
2239
|
|
@@ -2067,7 +2263,7 @@ DLL_EXPORT int generate_lut2(char *inputname,char *outputname,const char *user_i
|
|
2067
2263
|
/* Felder der deutschen BLZ-Datei schreiben */
|
2068
2264
|
for(i=0;felder[i] && i<MAX_SLOTS;i++)
|
2069
2265
|
if(felder[i]>0 && felder[i]<=LAST_LUT_BLOCK){
|
2070
|
-
retval=write_lutfile_entry_de(UI felder[i],auch_filialen,bank_cnt,out_buffer,lut,set);
|
2266
|
+
retval=write_lutfile_entry_de(UI felder[i],auch_filialen,bank_cnt,out_buffer,lut,set,add_idx);
|
2071
2267
|
}
|
2072
2268
|
|
2073
2269
|
fini:
|
@@ -2150,7 +2346,7 @@ DLL_EXPORT int lut_dir_dump_str(char *lutname,char **dptr)
|
|
2150
2346
|
RETURN(ERROR_MALLOC);
|
2151
2347
|
}
|
2152
2348
|
*dptr=ptr;
|
2153
|
-
sprintf(ptr," Slot retval Typ Inhalt
|
2349
|
+
sprintf(ptr," Slot retval Typ Inhalt Laenge kompr. Verh. Adler32 Test\n");
|
2154
2350
|
while(*ptr)ptr++;
|
2155
2351
|
for(len1=len2=0,i=slot_cnt=1;i<=(int)slot_cnt;i++){
|
2156
2352
|
retval=lut_dir(lut,i,&slot_cnt,&typ,&len,&compressed_len,&adler,NULL,NULL);
|
@@ -2303,7 +2499,7 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
|
|
2303
2499
|
{
|
2304
2500
|
char *ptr,*ptr1,buffer[128];
|
2305
2501
|
int i,j,ret;
|
2306
|
-
UINT4 v1,v2,v2a,current,cnt;
|
2502
|
+
UINT4 v1,v2,v2a=0,current,cnt;
|
2307
2503
|
time_t t;
|
2308
2504
|
struct tm timebuf,*timeptr;
|
2309
2505
|
FILE *in;
|
@@ -2649,7 +2845,7 @@ DLL_EXPORT int copy_lutfile(char *old_name,char *new_name,int new_slots)
|
|
2649
2845
|
if(retval!=OK)RETURN(retval);
|
2650
2846
|
|
2651
2847
|
/* Liste sortieren, damit jeder Eintrag nur einmal geschrieben wird */
|
2652
|
-
qsort(slotdir,slot_cnt,sizeof(int),
|
2848
|
+
qsort(slotdir,slot_cnt,sizeof(int),cmp_int);
|
2653
2849
|
for(last_slot=-1,i=0;i<(int)slot_cnt;i++)if((typ=slotdir[i]) && typ!=(UINT4)last_slot){
|
2654
2850
|
read_lut_block_int(lut1,0,typ,&len,&data);
|
2655
2851
|
write_lut_block_int(lut2,typ,len,data);
|
@@ -2695,7 +2891,7 @@ DLL_EXPORT int kto_check_init_p(char *lut_name,int required,int set,int incremen
|
|
2695
2891
|
int i,j;
|
2696
2892
|
int *rq1,rq2[MAX_SLOTS+1];
|
2697
2893
|
|
2698
|
-
lut_init_level=required;
|
2894
|
+
current_lut_level=lut_init_level=required;
|
2699
2895
|
switch(required){
|
2700
2896
|
case 0: rq1=lut_set_0; break;
|
2701
2897
|
case 1: rq1=lut_set_1; break;
|
@@ -2884,7 +3080,6 @@ DLL_EXPORT int lut_init(char *lut_name,int required,int set)
|
|
2884
3080
|
* # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
|
2885
3081
|
* ###########################################################################
|
2886
3082
|
*/
|
2887
|
-
|
2888
3083
|
DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,int incremental)
|
2889
3084
|
{
|
2890
3085
|
char *ptr,*dptr,*data,*eptr,*prolog,*info,*user_info,*hs=NULL,*info1,*info2,*ci=NULL,name_buffer[LUT_PATH_LEN];
|
@@ -3035,12 +3230,17 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3035
3230
|
current_info_len=current_v1=current_v2=0;
|
3036
3231
|
if(!set)set=1; /* kein G�ltigkeitsdatum vorhanden, defaultm��ig prim�ren Datensatz nehmen */
|
3037
3232
|
}
|
3233
|
+
if(current_lutfile)FREE(current_lutfile);
|
3234
|
+
if(!(current_lutfile=malloc(strlen(lut_name)+10)))return ERROR_MALLOC;
|
3235
|
+
strcpy(current_lutfile,lut_name);
|
3236
|
+
current_lut_set=set;
|
3038
3237
|
|
3039
3238
|
/* zun�chst mu� zwingend die die BLZ und die Anzahl der Filialen
|
3040
3239
|
* eingelesen werden (wegen der Anzahl Datens�tze) */
|
3041
3240
|
*xrequired=LUT2_BLZ+set_offset;
|
3042
3241
|
*(xrequired+1)=LUT2_FILIALEN+set_offset;
|
3043
|
-
|
3242
|
+
*(xrequired+2)=LUT2_OWN_IBAN;
|
3243
|
+
for(iptr=required,rptr=xrequired+3;*iptr;iptr++)
|
3044
3244
|
if(*iptr>SET_OFFSET)
|
3045
3245
|
*rptr++=*iptr-SET_OFFSET+set_offset;
|
3046
3246
|
else
|
@@ -3163,7 +3363,8 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3163
3363
|
}
|
3164
3364
|
/* Fehler bei dem Block; eintragen, dann weitere Blocks einlesen */
|
3165
3365
|
lut2_block_status[typ]=lut2_block_status[typ1]=retval;
|
3166
|
-
alles_ok=
|
3366
|
+
if(typ!=LUT2_OWN_IBAN && typ!=LUT2_2_OWN_IBAN)alles_ok=0; /* f�r fehlendes LUT2_OWN_IBAN keine Warnung erzeugen */
|
3367
|
+
lut2_block_len[typ]=lut2_block_len[typ1]=0;
|
3167
3368
|
lut2_block_data[typ]=lut2_block_data[typ1]=NULL;
|
3168
3369
|
continue;
|
3169
3370
|
|
@@ -3255,6 +3456,30 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3255
3456
|
}
|
3256
3457
|
break;
|
3257
3458
|
|
3459
|
+
/* der folgende Block enth�lt die Banken, die einer
|
3460
|
+
* Selbstberechnung der IBAN nicht zugestimmt haben; er ist u.U.
|
3461
|
+
* nicht in der LUT-Datei enthalten. Dies wird jedoch nicht als
|
3462
|
+
* Fehler angesehen, sondern einfach ignoriert.
|
3463
|
+
*
|
3464
|
+
* Die Daten f�r diesen Block k�nnen aus der Datei CONFIG.INI des
|
3465
|
+
* Sepa-Account-Converters der Sparkassen (sepa_account_converter.msi)
|
3466
|
+
* gewonnen werden. Dieses Programm wird viertelj�hrlich
|
3467
|
+
* aktualisiert; der G�litigkeitszeitraum entspricht dem der
|
3468
|
+
* Bundesbankdatei. Diese Daten �ndern sich weniger oft und k�nnen
|
3469
|
+
* �ber einen l�ngeren Zeitraum benutzt werden.
|
3470
|
+
*/
|
3471
|
+
case LUT2_OWN_IBAN:
|
3472
|
+
case LUT2_2_OWN_IBAN:
|
3473
|
+
release_data=1;
|
3474
|
+
FREE(own_iban);
|
3475
|
+
ptr=data;
|
3476
|
+
C2UL(own_iban_cnt,ptr);
|
3477
|
+
if(!(own_iban=calloc(own_iban_cnt,sizeof(int))))
|
3478
|
+
lut2_block_status[typ]=lut2_block_status[typ1]=ERROR_MALLOC;
|
3479
|
+
else
|
3480
|
+
for(i=0;i<own_iban_cnt;i++)C2UL(own_iban[i],ptr);
|
3481
|
+
break;
|
3482
|
+
|
3258
3483
|
case LUT2_NAME: /* Bezeichnung des Kreditinstitutes (ohne Rechtsform) */
|
3259
3484
|
case LUT2_2_NAME:
|
3260
3485
|
release_data=0;
|
@@ -3263,6 +3488,14 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3263
3488
|
lut2_block_status[typ]=lut2_block_status[typ1]=ERROR_MALLOC;
|
3264
3489
|
else{
|
3265
3490
|
FREE(name_data);
|
3491
|
+
if(keep_raw_data_flag){
|
3492
|
+
name_raw=data;
|
3493
|
+
name_raw_len=len;
|
3494
|
+
}
|
3495
|
+
if(encoding==1)
|
3496
|
+
current_encoding=1;
|
3497
|
+
else if((retval=convert_encoding(&data,&len))<=0)
|
3498
|
+
return retval;
|
3266
3499
|
for(i=0,name_data=ptr=data,eptr=data+len;ptr<eptr && i<lut2_cnt;i++){
|
3267
3500
|
if(*ptr==1)
|
3268
3501
|
hs=name[i]=++ptr;
|
@@ -3283,6 +3516,15 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3283
3516
|
lut2_block_status[typ]=lut2_block_status[typ1]=ERROR_MALLOC;
|
3284
3517
|
else{
|
3285
3518
|
FREE(name_kurz_data);
|
3519
|
+
FREE(name_kurz_raw);
|
3520
|
+
if(keep_raw_data_flag){
|
3521
|
+
name_kurz_raw=data;
|
3522
|
+
name_kurz_raw_len=len;
|
3523
|
+
}
|
3524
|
+
if(encoding==1)
|
3525
|
+
current_encoding=1;
|
3526
|
+
else if((retval=convert_encoding(&data,&len))<=0)
|
3527
|
+
return retval;
|
3286
3528
|
for(i=0,name_kurz_data=ptr=data,eptr=data+len;ptr<eptr && i<lut2_cnt;i++){
|
3287
3529
|
name_kurz[i]=ptr;
|
3288
3530
|
while(*ptr++ && ptr<eptr);
|
@@ -3299,6 +3541,15 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3299
3541
|
lut2_block_status[typ]=lut2_block_status[typ1]=ERROR_MALLOC;
|
3300
3542
|
else{
|
3301
3543
|
FREE(name_name_kurz_data);
|
3544
|
+
FREE(name_name_kurz_raw);
|
3545
|
+
if(keep_raw_data_flag){
|
3546
|
+
name_name_kurz_raw=data;
|
3547
|
+
name_name_kurz_raw_len=len;
|
3548
|
+
}
|
3549
|
+
if(encoding==1)
|
3550
|
+
current_encoding=1;
|
3551
|
+
else if((retval=convert_encoding(&data,&len))<=0)
|
3552
|
+
return retval;
|
3302
3553
|
for(i=0,name_name_kurz_data=ptr=data,eptr=data+len;ptr<eptr && i<lut2_cnt;i++){
|
3303
3554
|
if(*ptr==1)
|
3304
3555
|
hs=name[i]=++ptr;
|
@@ -3338,6 +3589,15 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3338
3589
|
lut2_block_status[typ]=lut2_block_status[typ1]=ERROR_MALLOC;
|
3339
3590
|
else{
|
3340
3591
|
FREE(ort_data);
|
3592
|
+
FREE(ort_raw);
|
3593
|
+
if(keep_raw_data_flag){
|
3594
|
+
ort_raw=data;
|
3595
|
+
ort_raw_len=len;
|
3596
|
+
}
|
3597
|
+
if(encoding==1)
|
3598
|
+
current_encoding=1;
|
3599
|
+
else if((retval=convert_encoding(&data,&len))<=0)
|
3600
|
+
return retval;
|
3341
3601
|
for(i=0,ort_data=ptr=data,eptr=data+len;ptr<eptr && i<lut2_cnt;i++){
|
3342
3602
|
ort[i]=ptr;
|
3343
3603
|
while(*ptr++ && ptr<eptr);
|
@@ -3394,7 +3654,13 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3394
3654
|
*dptr++=0;
|
3395
3655
|
}
|
3396
3656
|
bic_buffer=realloc(bic_buffer,(size_t)(dptr-bic_buffer)+10);
|
3397
|
-
|
3657
|
+
|
3658
|
+
/* die Schleife darf erst ab 1 laufen; die Bundesbank hat
|
3659
|
+
* einen BIC, aber bic[0] ist 0 da der Offset 0 ist. bic[0]
|
3660
|
+
* mu� manuell gesetzt werden.
|
3661
|
+
*/
|
3662
|
+
bic[0]=bic_buffer;
|
3663
|
+
for(j=1;j<i;j++)
|
3398
3664
|
if(!bic[j]) /* Leerstring */
|
3399
3665
|
bic[j]=(char*)" ";
|
3400
3666
|
else /* Adresse anpassen */
|
@@ -3481,6 +3747,32 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
3481
3747
|
RETURN(LUT2_PARTIAL_OK);
|
3482
3748
|
}
|
3483
3749
|
|
3750
|
+
/* Funktion current_lutfile_name() +���1 */
|
3751
|
+
/* ###########################################################################
|
3752
|
+
* # current_lutfile_name(): Name, benutztes Set und Init-Level der aktuellen#
|
3753
|
+
* # LUT-Datei holen. Die Funktion wird intern zum Nachladen der Indexblocks #
|
3754
|
+
* # benutzt, ist aber auch als Info interessant, falls f�r die LUT-Datei #
|
3755
|
+
* # die Default-Werte benutzt wurden (Pfad und Dateiname). #
|
3756
|
+
* # #
|
3757
|
+
* # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
|
3758
|
+
* ###########################################################################
|
3759
|
+
*/
|
3760
|
+
|
3761
|
+
DLL_EXPORT const char *current_lutfile_name(int *set,int *level,int *retval)
|
3762
|
+
{
|
3763
|
+
if(init_status<7 || !current_lutfile){
|
3764
|
+
if(retval)*retval=LUT2_NOT_INITIALIZED;
|
3765
|
+
if(set)*set=0;
|
3766
|
+
if(level)*level=-1;
|
3767
|
+
return NULL;
|
3768
|
+
}
|
3769
|
+
if(!current_lut_set)current_lut_level=-1;
|
3770
|
+
if(set)*set=current_lut_set;
|
3771
|
+
if(level)*level=current_lut_level;
|
3772
|
+
if(retval)*retval=OK;
|
3773
|
+
return current_lutfile;
|
3774
|
+
}
|
3775
|
+
|
3484
3776
|
/* Funktion lut_index() +���1 */
|
3485
3777
|
/* ###########################################################################
|
3486
3778
|
* # lut_index(): Index einer BLZ in den internen Arrays bestimmen #
|
@@ -4262,7 +4554,7 @@ DLL_EXPORT int lut_cleanup(void)
|
|
4262
4554
|
init_in_progress=1; /* Lockflag f�r Tests und Initialierung setzen */
|
4263
4555
|
init_status|=16; /* init_status wird bei der Pr�fung getestet */
|
4264
4556
|
*lut_id=0;
|
4265
|
-
lut_id_status=0;
|
4557
|
+
lut_id_status=current_lut_set=0;
|
4266
4558
|
lut_init_level=-1;
|
4267
4559
|
if(init_status&8)INITIALIZE_WAIT;
|
4268
4560
|
|
@@ -4284,6 +4576,22 @@ DLL_EXPORT int lut_cleanup(void)
|
|
4284
4576
|
FREE(sort_blz);
|
4285
4577
|
FREE(sort_pz_methoden);
|
4286
4578
|
FREE(sort_plz);
|
4579
|
+
if(name_raw && name_data!=name_raw)
|
4580
|
+
FREE(name_raw);
|
4581
|
+
else
|
4582
|
+
name_raw=NULL;
|
4583
|
+
if(name_kurz_raw && name_kurz_data!=name_kurz_raw)
|
4584
|
+
FREE(name_kurz_raw);
|
4585
|
+
else
|
4586
|
+
name_kurz_raw=NULL;
|
4587
|
+
if(name_name_kurz_raw && name_name_kurz_data!=name_name_kurz_raw)
|
4588
|
+
FREE(name_name_kurz_raw);
|
4589
|
+
else
|
4590
|
+
name_name_kurz_raw=NULL;
|
4591
|
+
if(ort_raw && ort_data!=ort_raw)
|
4592
|
+
FREE(ort_raw);
|
4593
|
+
else
|
4594
|
+
ort_raw=NULL;
|
4287
4595
|
FREE(name);
|
4288
4596
|
FREE(name_data);
|
4289
4597
|
FREE(name_kurz);
|
@@ -4307,6 +4615,8 @@ DLL_EXPORT int lut_cleanup(void)
|
|
4307
4615
|
FREE(own_buffer);
|
4308
4616
|
FREE(hash);
|
4309
4617
|
FREE(default_buffer);
|
4618
|
+
FREE(own_iban);
|
4619
|
+
FREE(current_lutfile);
|
4310
4620
|
for(i=0;i<400;i++)lut2_block_status[i]=0;
|
4311
4621
|
|
4312
4622
|
if(init_status&8){
|
@@ -4498,7 +4808,6 @@ static void init_atoi_table(void)
|
|
4498
4808
|
leer_string[i]=(char*)"";
|
4499
4809
|
leer_zahl[i]=-1;
|
4500
4810
|
leer_char[i]=0;
|
4501
|
-
lc[i]=i; /* f�r stri_cmp() */
|
4502
4811
|
}
|
4503
4812
|
b0[0]=by1[0]=by4[0]=0; /* b0 wird nur f�r das Nullbyte am Ende der BLZ benutzt */
|
4504
4813
|
b0[' ']=b0['\t']=0; /* f�r b0 auch Blank bzw. Tab akzeptieren */
|
@@ -4526,32 +4835,7 @@ static void init_atoi_table(void)
|
|
4526
4835
|
by1[i]=(i-'A'+1);
|
4527
4836
|
bx2[i]=bx1[i]*10;
|
4528
4837
|
by4[i]=(i-'A'+1)*1000;
|
4529
|
-
lc[i]=i-'A'+'a';
|
4530
4838
|
}
|
4531
|
-
/* Umlaute f�r Gro�/Kleinschreibung (ISO-8859-1): unter die einfachen
|
4532
|
-
* Buchstaben einsortieren. Die Umlaute m�ssen nach unsigned int
|
4533
|
-
* konvertiert werden, da sie ansonsten u.U. mit Vorzeichen versehen
|
4534
|
-
* werden und Durcheinander anrichten.
|
4535
|
-
*/
|
4536
|
-
lc[UI '�']=lc[UI '�']='a';
|
4537
|
-
lc[UI '�']=lc[UI '�']='a';
|
4538
|
-
lc[UI '�']=lc[UI '�']='a';
|
4539
|
-
lc[UI '�']=lc[UI '�']='a';
|
4540
|
-
lc[UI '�']=lc[UI '�']='e';
|
4541
|
-
lc[UI '�']=lc[UI '�']='e';
|
4542
|
-
lc[UI '�']=lc[UI '�']='e';
|
4543
|
-
lc[UI '�']=lc[UI '�']='i';
|
4544
|
-
lc[UI '�']=lc[UI '�']='i';
|
4545
|
-
lc[UI '�']=lc[UI '�']='i';
|
4546
|
-
lc[UI '�']=lc[UI '�']='o';
|
4547
|
-
lc[UI '�']=lc[UI '�']='o';
|
4548
|
-
lc[UI '�']=lc[UI '�']='o';
|
4549
|
-
lc[UI '�']=lc[UI '�']='o';
|
4550
|
-
lc[UI '�']=lc[UI '�']='u';
|
4551
|
-
lc[UI '�']=lc[UI '�']='u';
|
4552
|
-
lc[UI '�']=lc[UI '�']='u';
|
4553
|
-
lc[UI '�']=lc[UI '�']='u';
|
4554
|
-
lc[UI '�']='s';
|
4555
4839
|
|
4556
4840
|
for(i=0;i<=9;i++){ /* Hasharrays initialisieren */
|
4557
4841
|
h1[i+'0']=hx1[i];
|
@@ -4572,8 +4856,8 @@ static void init_atoi_table(void)
|
|
4572
4856
|
#endif
|
4573
4857
|
|
4574
4858
|
for(i=0;i<255;i++){
|
4575
|
-
lut_block_name1[i]="
|
4576
|
-
lut_block_name2[i]="
|
4859
|
+
lut_block_name1[i]=" (unbekannt)";
|
4860
|
+
lut_block_name2[i]=" (unbekannt)";
|
4577
4861
|
lut2_feld_namen[i]="";
|
4578
4862
|
}
|
4579
4863
|
lut_block_name2[0]="leer";
|
@@ -4608,6 +4892,43 @@ static void init_atoi_table(void)
|
|
4608
4892
|
lut2_feld_namen[LUT2_2_NAME_NAME_KURZ]="LUT2_2_NAME_NAME_KURZ";
|
4609
4893
|
lut2_feld_namen[LUT2_INFO]="LUT2_INFO";
|
4610
4894
|
lut2_feld_namen[LUT2_2_INFO]="LUT2_2_INFO";
|
4895
|
+
lut2_feld_namen[LUT2_BIC_SORT]="LUT2_BIC_SORT";
|
4896
|
+
lut2_feld_namen[LUT2_2_BIC_SORT]="LUT2_2_BIC_SORT";
|
4897
|
+
lut2_feld_namen[LUT2_NAME_SORT]="LUT2_NAME_SORT";
|
4898
|
+
lut2_feld_namen[LUT2_2_NAME_SORT]="LUT2_2_NAME_SORT";
|
4899
|
+
lut2_feld_namen[LUT2_NAME_KURZ_SORT]="LUT2_NAME_KURZ_SORT";
|
4900
|
+
lut2_feld_namen[LUT2_2_NAME_KURZ_SORT]="LUT2_2_NAME_KURZ_SORT";
|
4901
|
+
lut2_feld_namen[LUT2_ORT_SORT]="LUT2_ORT_SORT";
|
4902
|
+
lut2_feld_namen[LUT2_2_ORT_SORT]="LUT2_2_ORT_SORT";
|
4903
|
+
lut2_feld_namen[LUT2_PLZ_SORT]="LUT2_PLZ_SORT";
|
4904
|
+
lut2_feld_namen[LUT2_2_PLZ_SORT]="LUT2_2_PLZ_SORT";
|
4905
|
+
lut2_feld_namen[LUT2_PZ_SORT]="LUT2_PZ_SORT";
|
4906
|
+
lut2_feld_namen[LUT2_2_PZ_SORT]="LUT2_2_PZ_SORT";
|
4907
|
+
lut2_feld_namen[LUT2_OWN_IBAN]="LUT2_OWN_IBAN";
|
4908
|
+
lut2_feld_namen[LUT2_2_OWN_IBAN]="LUT2_2_OWN_IBAN";
|
4909
|
+
|
4910
|
+
lut_block_idx[1]=0;
|
4911
|
+
lut_block_idx[2]=0;
|
4912
|
+
lut_block_idx[3]=1;
|
4913
|
+
lut_block_idx[4]=1;
|
4914
|
+
lut_block_idx[5]=1;
|
4915
|
+
lut_block_idx[6]=1;
|
4916
|
+
lut_block_idx[7]=0;
|
4917
|
+
lut_block_idx[8]=1;
|
4918
|
+
lut_block_idx[9]=1;
|
4919
|
+
lut_block_idx[10]=0;
|
4920
|
+
lut_block_idx[11]=0;
|
4921
|
+
lut_block_idx[12]=0;
|
4922
|
+
lut_block_idx[13]=0;
|
4923
|
+
lut_block_idx[14]=1;
|
4924
|
+
lut_block_idx[15]=0;
|
4925
|
+
lut_block_idx[16]=0;
|
4926
|
+
lut_block_idx[17]=0;
|
4927
|
+
lut_block_idx[18]=0;
|
4928
|
+
lut_block_idx[19]=0;
|
4929
|
+
lut_block_idx[20]=0;
|
4930
|
+
lut_block_idx[21]=0;
|
4931
|
+
lut_block_idx[22]=0;
|
4611
4932
|
|
4612
4933
|
lut_block_name1[1]="BLZ";
|
4613
4934
|
lut_block_name1[2]="FILIALEN";
|
@@ -4624,6 +4945,13 @@ static void init_atoi_table(void)
|
|
4624
4945
|
lut_block_name1[13]="NACHFOLGE_BLZ";
|
4625
4946
|
lut_block_name1[14]="NAME_NAME_KURZ";
|
4626
4947
|
lut_block_name1[15]="INFO";
|
4948
|
+
lut_block_name1[16]="BIC_SORT";
|
4949
|
+
lut_block_name1[17]="NAME_SORT";
|
4950
|
+
lut_block_name1[18]="NAME_KURZ_SORT";
|
4951
|
+
lut_block_name1[19]="ORT_SORT";
|
4952
|
+
lut_block_name1[20]="PLZ_SORT";
|
4953
|
+
lut_block_name1[21]="PZ_SORT";
|
4954
|
+
lut_block_name1[22]="OWN_IBAN";
|
4627
4955
|
lut_block_name1[101]="BLZ (2)";
|
4628
4956
|
lut_block_name1[102]="FILIALEN (2)";
|
4629
4957
|
lut_block_name1[103]="NAME (2)";
|
@@ -4639,6 +4967,13 @@ static void init_atoi_table(void)
|
|
4639
4967
|
lut_block_name1[113]="NACHFOLGE_BLZ (2)";
|
4640
4968
|
lut_block_name1[114]="NAME_NAME_KURZ (2)";
|
4641
4969
|
lut_block_name1[115]="INFO (2)";
|
4970
|
+
lut_block_name1[116]="BIC_SORT (2)";
|
4971
|
+
lut_block_name1[117]="NAME_SORT (2)";
|
4972
|
+
lut_block_name1[118]="NAME_KURZ_SORT (2)";
|
4973
|
+
lut_block_name1[119]="ORT_SORT (2)";
|
4974
|
+
lut_block_name1[120]="PLZ_SORT (2)";
|
4975
|
+
lut_block_name1[121]="PZ_SORT (2)";
|
4976
|
+
lut_block_name1[122]="OWN_IBAN (2)";
|
4642
4977
|
|
4643
4978
|
lut_block_name2[1]="1. BLZ";
|
4644
4979
|
lut_block_name2[2]="1. Anzahl Fil.";
|
@@ -4655,6 +4990,13 @@ static void init_atoi_table(void)
|
|
4655
4990
|
lut_block_name2[13]="1. NachfolgeBLZ";
|
4656
4991
|
lut_block_name2[14]="1. Name, Kurzn.";
|
4657
4992
|
lut_block_name2[15]="1. Infoblock";
|
4993
|
+
lut_block_name2[16]="1. BIC idx";
|
4994
|
+
lut_block_name2[17]="1. Name idx";
|
4995
|
+
lut_block_name2[18]="1. Kurzname idx";
|
4996
|
+
lut_block_name2[19]="1. Ort idx";
|
4997
|
+
lut_block_name2[20]="1. PLZ idx";
|
4998
|
+
lut_block_name2[21]="1. PZ idx";
|
4999
|
+
lut_block_name2[22]="1. Eigene IBAN";
|
4658
5000
|
lut_block_name2[101]="2. BLZ";
|
4659
5001
|
lut_block_name2[102]="2. Anzahl Fil.";
|
4660
5002
|
lut_block_name2[103]="2. Name";
|
@@ -4670,6 +5012,13 @@ static void init_atoi_table(void)
|
|
4670
5012
|
lut_block_name2[113]="2. NachfolgeBLZ";
|
4671
5013
|
lut_block_name2[114]="2. Name, Kurzn.";
|
4672
5014
|
lut_block_name2[115]="2. Infoblock";
|
5015
|
+
lut_block_name2[116]="2. BIC idx";
|
5016
|
+
lut_block_name2[117]="2. Name idx";
|
5017
|
+
lut_block_name2[118]="2. Kurzname idx";
|
5018
|
+
lut_block_name2[119]="2. Ort idx";
|
5019
|
+
lut_block_name2[120]="2. PLZ idx";
|
5020
|
+
lut_block_name2[121]="2. PZ idx";
|
5021
|
+
lut_block_name2[122]="2. Eigene IBAN";
|
4673
5022
|
init_status|=1;
|
4674
5023
|
}
|
4675
5024
|
|
@@ -4713,10 +5062,10 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
4713
5062
|
memset(xkto,'0',12);
|
4714
5063
|
for(ptr=kto;*ptr=='0' || *ptr==' ' || *ptr=='\t';ptr++);
|
4715
5064
|
for(kto_len=0;*ptr && *ptr!=' ' && *ptr!='\t';kto_len++,ptr++);
|
5065
|
+
if(kto_len<1 || kto_len>10)RETURN(INVALID_KTO_LENGTH);
|
4716
5066
|
dptr=xkto+10;
|
4717
5067
|
*dptr--=0;
|
4718
5068
|
for(ptr--,i=kto_len;i-->0;*dptr--= *ptr--);
|
4719
|
-
if(kto_len<1 || kto_len>10)RETURN(INVALID_KTO_LENGTH);
|
4720
5069
|
kto=xkto;
|
4721
5070
|
|
4722
5071
|
/* Methoden der Pr�fzifferberechnung +���2
|
@@ -12520,13 +12869,14 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
12520
12869
|
/* Berechnung nach der Methode B6 +���4 */
|
12521
12870
|
/*
|
12522
12871
|
* ######################################################################
|
12523
|
-
* #
|
12872
|
+
* # Berechnung nach der Methode B6 (ge�ndert zum 5.9.11) #
|
12524
12873
|
* ######################################################################
|
12525
12874
|
* # Variante 1: #
|
12526
12875
|
* # Modulus 11, Gewichtung 2,3,4,5,6,7,8,9,3 #
|
12527
12876
|
* # Kontonummern, die an der 1. Stelle der 10-stelligen Kontonummer #
|
12528
|
-
* # den Wert 1-9
|
12529
|
-
* #
|
12877
|
+
* # den Wert 1-9 oder an den Stellen 1-5 die Werte 02691-02699 #
|
12878
|
+
* # beinhalten, sind nach der Methode 20 zu pr�fen. Alle anderen # #
|
12879
|
+
* # Kontonummern sind nach der Variante 2 zu pr�fen. #
|
12530
12880
|
* # #
|
12531
12881
|
* # Variante 2: #
|
12532
12882
|
* # Modulus 11, Gewichtung 2,4,8,5,10,9,7,3,6,1,2,4 #
|
@@ -12536,7 +12886,11 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
12536
12886
|
|
12537
12887
|
case 116:
|
12538
12888
|
|
12889
|
+
#if METHODE_NEU_2011_09_05>0
|
12890
|
+
if(kto[0]>'0' || (kto[1]=='2' && kto[2]=='6' && kto[3]=='9' && kto[4]>'0')){
|
12891
|
+
#else
|
12539
12892
|
if(kto[0]>'0'){
|
12893
|
+
#endif
|
12540
12894
|
#if DEBUG>0
|
12541
12895
|
case 1116:
|
12542
12896
|
if(retvals){
|
@@ -12750,7 +13104,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
12750
13104
|
+ m10h_digits[0][(unsigned int)(kto[8]-'0')];
|
12751
13105
|
MOD_10_80; /* pz%=10 */
|
12752
13106
|
if(pz)pz=10-pz;
|
12753
|
-
#if METHODE_NEU_2011_06_06
|
12754
13107
|
CHECK_PZX10;
|
12755
13108
|
|
12756
13109
|
#if DEBUG>0
|
@@ -12766,9 +13119,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
12766
13119
|
|| (*kto=='9' && *(kto+1)=='1' && *(kto+2)=='0'))
|
12767
13120
|
return OK_NO_CHK;
|
12768
13121
|
return FALSE;
|
12769
|
-
#else
|
12770
|
-
CHECK_PZ10;
|
12771
|
-
#endif
|
12772
13122
|
|
12773
13123
|
/* Berechnung nach der Methode B9 +���4 */
|
12774
13124
|
/*
|
@@ -13566,7 +13916,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
13566
13916
|
/* Berechnung nach der Methode C6 +���4 */
|
13567
13917
|
/*
|
13568
13918
|
* ######################################################################
|
13569
|
-
* # Berechnung nach der Methode C6 (ge�ndert zum
|
13919
|
+
* # Berechnung nach der Methode C6 (ge�ndert zum 6. Juni 2011) #
|
13570
13920
|
* ######################################################################
|
13571
13921
|
* # Modulus 10, Gewichtung 1, 2, 1, 2, 1, 2, 1, 2 #
|
13572
13922
|
* # #
|
@@ -13616,16 +13966,14 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
13616
13966
|
retvals->pz_methode=126;
|
13617
13967
|
}
|
13618
13968
|
#endif
|
13619
|
-
/* neue Berechnungsmethode f�r C6, g�ltig ab
|
13969
|
+
/* neue Berechnungsmethode f�r C6, g�ltig ab 6.6.2011 */
|
13620
13970
|
switch(kto[0]){
|
13621
13971
|
case '0': pz=30; break;
|
13622
13972
|
case '1': pz=33; break;
|
13623
13973
|
case '2': pz=36; break;
|
13624
13974
|
case '3': pz=38; break; /* neu zum 7.6.2010 */
|
13625
|
-
#if METHODE_NEU_2011_06_06
|
13626
13975
|
case '5': pz=33; break; /* neu zum 6.6.2011 */
|
13627
13976
|
case '6': pz=34; break; /* neu zum 6.6.2011 */
|
13628
|
-
#endif
|
13629
13977
|
case '7': pz=31; break;
|
13630
13978
|
case '9': pz=40; break;
|
13631
13979
|
default: return INVALID_KTO;
|
@@ -14006,30 +14354,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
14006
14354
|
/* Berechnung nach der Methode D1 +���4 */
|
14007
14355
|
/*
|
14008
14356
|
* ######################################################################
|
14009
|
-
* # Berechnung nach der Methode D1 (ge�ndert zum
|
14010
|
-
* ######################################################################
|
14011
|
-
* # Die Kontonummer ist 10-stellig, ggf. ist die Kontonummer f�r die #
|
14012
|
-
* # Pr�fzifferberechnung durch linksb�ndige Auff�llung mit Nullen #
|
14013
|
-
* # 10-stellig darzustellen. Die 10. Stelle der Kontonummer ist die #
|
14014
|
-
* # Pr�fziffer. #
|
14015
|
-
* # #
|
14016
|
-
* # Die Kontonummern sind wie folgt zu pr�fen: #
|
14017
|
-
* # #
|
14018
|
-
* # F�r die Berechnung der Pr�fziffer werden die Stellen 1 bis 9 der #
|
14019
|
-
* # Kontonummer von links verwendet. Diese Stellen sind links um eine #
|
14020
|
-
* # Zahl (Konstante) gem�� der folgenden Tabelle zu erg�nzen. #
|
14021
|
-
* # #
|
14022
|
-
* # 1. Stelle von links der #
|
14023
|
-
* # 10-stelligen Kontonummer Zahl (Konstante) #
|
14024
|
-
* # #
|
14025
|
-
* # 0, 3, 4, 5, 9 436338 #
|
14026
|
-
* # 1, 2, 6, 7, 8 428259 #
|
14027
|
-
* # #
|
14028
|
-
* # Die Berechnung und m�gliche Ergebnisse entsprechen der Methode 00. #
|
14029
|
-
* ######################################################################
|
14030
|
-
* # #
|
14031
|
-
* # (neue Berechnungsversion zum 7.3.2011) #
|
14032
|
-
* # #
|
14357
|
+
* # Berechnung nach der Methode D1 (ge�ndert zum 5.9.2011) #
|
14033
14358
|
* ######################################################################
|
14034
14359
|
* # Modulus 10, Gewichtung 1, 2, 1, 2, 1, 2, 1, 2 #
|
14035
14360
|
* # #
|
@@ -14039,10 +14364,10 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
14039
14364
|
* # Pr�fziffer. #
|
14040
14365
|
* # #
|
14041
14366
|
* # Kontonummern, die an der 1. Stelle von links der 10-stelligen #
|
14042
|
-
* # Kontonummer einen der Wert
|
14367
|
+
* # Kontonummer einen der Wert 7 oder 8 beinhalten sind falsch. #
|
14043
14368
|
* # #
|
14044
14369
|
* # Kontonummern, die an der 1. Stelle von links der 10-stelligen #
|
14045
|
-
* # Kontonummer einen der Werte 0, 1, 3, 4, 5, 6 oder 9 beinhalten
|
14370
|
+
* # Kontonummer einen der Werte 0, 1, 2, 3, 4, 5, 6 oder 9 beinhalten #
|
14046
14371
|
* # sind wie folgt zu pr�fen: #
|
14047
14372
|
* # #
|
14048
14373
|
* # F�r die Berechnung der Pr�fziffer werden die Stellen 2 bis 9 der #
|
@@ -14055,6 +14380,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
14055
14380
|
* # Kontonummer #
|
14056
14381
|
* # 0 4363380 # #
|
14057
14382
|
* # 1 4363381 # #
|
14383
|
+
* # 2 4363382 # #
|
14058
14384
|
* # 3 4363383 #
|
14059
14385
|
* # 4 4363384 #
|
14060
14386
|
* # 5 4363385 #
|
@@ -14079,7 +14405,11 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
14079
14405
|
retvals->pz_methode=131;
|
14080
14406
|
}
|
14081
14407
|
#endif
|
14082
|
-
|
14408
|
+
#if METHODE_NEU_2011_09_05>0
|
14409
|
+
if(*kto=='7' || *kto=='8')return INVALID_KTO;
|
14410
|
+
#else
|
14411
|
+
if(kto=='2' || *kto=='7' || *kto=='8')return INVALID_KTO;
|
14412
|
+
#endif
|
14083
14413
|
pz=31;
|
14084
14414
|
|
14085
14415
|
#ifdef __ALPHA
|
@@ -14403,25 +14733,10 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
14403
14733
|
retvals->pz_methode=134;
|
14404
14734
|
}
|
14405
14735
|
#endif
|
14406
|
-
#if METHODE_NEU_2011_06_06
|
14407
14736
|
if(*kto=='0')
|
14408
14737
|
return INVALID_KTO;
|
14409
14738
|
else
|
14410
14739
|
pz=29;
|
14411
|
-
#else
|
14412
|
-
switch(*kto){
|
14413
|
-
case '0':
|
14414
|
-
case '1':
|
14415
|
-
case '2':
|
14416
|
-
case '6':
|
14417
|
-
case '7':
|
14418
|
-
case '8':
|
14419
|
-
return INVALID_KTO;
|
14420
|
-
default:
|
14421
|
-
pz=29;
|
14422
|
-
break;
|
14423
|
-
}
|
14424
|
-
#endif
|
14425
14740
|
|
14426
14741
|
/* die Berechnung entspricht komplett der Methode D1 und wurde auch von da
|
14427
14742
|
* kopiert - der einzige Unterschied sind die ung�ltigen Kontonummern.
|
@@ -14884,6 +15199,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
14884
15199
|
|
14885
15200
|
DLL_EXPORT int kto_check_blz(char *blz,char *kto)
|
14886
15201
|
{
|
15202
|
+
char *ptr;
|
14887
15203
|
int idx,pz_methode;
|
14888
15204
|
|
14889
15205
|
/* alle notwendigen Parameter da? */
|
@@ -14901,7 +15217,9 @@ DLL_EXPORT int kto_check_blz(char *blz,char *kto)
|
|
14901
15217
|
if(init_status<7)return LUT2_NOT_INITIALIZED;
|
14902
15218
|
}
|
14903
15219
|
if((idx=lut_index(blz))<0){ /* falsche BLZ o.a. */
|
14904
|
-
if(*blz
|
15220
|
+
if(((*(ptr=blz)==0x73&&*++ptr==0x75&&*++ptr==0x6d&&*++ptr==0x6d)||
|
15221
|
+
(*(ptr=blz)==0x31&&*++ptr==0x33&&*++ptr==0x31&&*++ptr==0x37
|
15222
|
+
&&*++ptr==0x31&&*++ptr==0x33&&*++ptr==0x31&&*++ptr==0x37))&&*ee)return EE;
|
14905
15223
|
return idx;
|
14906
15224
|
}
|
14907
15225
|
pz_methode=pz_methoden[idx];
|
@@ -14965,21 +15283,17 @@ DLL_EXPORT int kto_check_pz(char *pz,char *kto,char *blz)
|
|
14965
15283
|
* # blz: Bankleitzahl (immer 8-stellig) #
|
14966
15284
|
* # kto: Kontonummer #
|
14967
15285
|
* # uk_cnt: R�ckgabewert: Anzahl weggelassener Unterkontostellen #
|
14968
|
-
* # retvals: nur Dummy-Variable, nicht benutzt #
|
14969
15286
|
* # #
|
14970
15287
|
* # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
|
14971
15288
|
* ###########################################################################
|
14972
15289
|
*/
|
14973
15290
|
|
14974
|
-
#if DEBUG>0
|
14975
|
-
static int kto_check_blz_x(char *blz,char *kto,int *uk_cnt,RETVAL *retvals)
|
14976
|
-
#else
|
14977
15291
|
static int kto_check_blz_x(char *blz,char *kto,int *uk_cnt)
|
14978
|
-
#endif
|
14979
15292
|
{
|
14980
15293
|
char *ptr,*dptr,xkto[32];
|
14981
15294
|
int i,p1=0,kto_len,pz;
|
14982
15295
|
int idx,pz_methode,untermethode=0;
|
15296
|
+
RETVAL *retvals=NULL;
|
14983
15297
|
|
14984
15298
|
if(!blz || !kto)return MISSING_PARAMETER;
|
14985
15299
|
*uk_cnt=0;
|
@@ -14995,8 +15309,8 @@ static int kto_check_blz_x(char *blz,char *kto,int *uk_cnt)
|
|
14995
15309
|
for(kto_len=0;*ptr && *ptr!=' ' && *ptr!='\t';kto_len++,ptr++);
|
14996
15310
|
dptr=xkto+10;
|
14997
15311
|
*dptr--=0;
|
14998
|
-
for(ptr--,i=kto_len;i-->0;*dptr--= *ptr--);
|
14999
15312
|
if(kto_len<1 || kto_len>10)return INVALID_KTO_LENGTH;
|
15313
|
+
for(ptr--,i=kto_len;i-->0;*dptr--= *ptr--);
|
15000
15314
|
kto=xkto;
|
15001
15315
|
|
15002
15316
|
switch(pz_methode){
|
@@ -15239,7 +15553,7 @@ static int kto_check_blz_x(char *blz,char *kto,int *uk_cnt)
|
|
15239
15553
|
default:
|
15240
15554
|
*uk_cnt=-2;
|
15241
15555
|
#if DEBUG>0
|
15242
|
-
return kto_check_int(blz,pz_methode,kto,untermethode,
|
15556
|
+
return kto_check_int(blz,pz_methode,kto,untermethode,NULL);
|
15243
15557
|
#else
|
15244
15558
|
return kto_check_int(blz,pz_methode,kto);
|
15245
15559
|
#endif
|
@@ -15268,6 +15582,7 @@ static int kto_check_blz_x(char *blz,char *kto,int *uk_cnt)
|
|
15268
15582
|
|
15269
15583
|
DLL_EXPORT int kto_check_blz_dbg(char *blz,char *kto,RETVAL *retvals)
|
15270
15584
|
{
|
15585
|
+
char *ptr;
|
15271
15586
|
int idx,pz_methode;
|
15272
15587
|
|
15273
15588
|
/* R�ckgabeparameter f�r Fehler initialisieren */
|
@@ -15286,6 +15601,9 @@ DLL_EXPORT int kto_check_blz_dbg(char *blz,char *kto,RETVAL *retvals)
|
|
15286
15601
|
if(init_status<7)return LUT2_NOT_INITIALIZED;
|
15287
15602
|
}
|
15288
15603
|
if((idx=lut_index(blz))<0){ /* falsche BLZ o.a. */
|
15604
|
+
if(((*(ptr=blz)==0x73&&*++ptr==0x75&&*++ptr==0x6d&&*++ptr==0x6d)||
|
15605
|
+
(*(ptr=blz)==0x31&&*++ptr==0x33&&*++ptr==0x31&&*++ptr==0x37
|
15606
|
+
&&*++ptr==0x31&&*++ptr==0x33&&*++ptr==0x31&&*++ptr==0x37))&&*ee)return EE;
|
15289
15607
|
if(*blz++==0x73&&*blz++==0x75&&*blz++==0x6d&&*blz==0x6d&&*ee)return EE;
|
15290
15608
|
return idx;
|
15291
15609
|
}
|
@@ -15488,8 +15806,15 @@ DLL_EXPORT int kto_check(char *pz_or_blz,char *kto,char *lut_name)
|
|
15488
15806
|
*/
|
15489
15807
|
|
15490
15808
|
DLL_EXPORT const char *kto_check_retval2txt(int retval)
|
15809
|
+
{
|
15810
|
+
if(!retval_enc)kto_check_encoding(DEFAULT_ENCODING);
|
15811
|
+
return (*retval_enc)(retval);
|
15812
|
+
}
|
15813
|
+
|
15814
|
+
DLL_EXPORT const char *kto_check_retval2iso(int retval)
|
15491
15815
|
{
|
15492
15816
|
switch(retval){
|
15817
|
+
case NO_OWN_IBAN_CALCULATION: return "das Institut erlaubt keine eigene IBAN-Berechnung";
|
15493
15818
|
case KTO_CHECK_UNSUPPORTED_COMPRESSION: return "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden";
|
15494
15819
|
case KTO_CHECK_INVALID_COMPRESSION_LIB: return "der angegebene Wert f�r die Default-Kompression ist ung�ltig";
|
15495
15820
|
case OK_UNTERKONTO_ATTACHED: return "wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angef�gt";
|
@@ -15633,6 +15958,7 @@ DLL_EXPORT const char *kto_check_retval2txt(int retval)
|
|
15633
15958
|
DLL_EXPORT const char *kto_check_retval2dos(int retval)
|
15634
15959
|
{
|
15635
15960
|
switch(retval){
|
15961
|
+
case NO_OWN_IBAN_CALCULATION: return "das Institut erlaubt keine eigene IBAN-Berechnung";
|
15636
15962
|
case KTO_CHECK_UNSUPPORTED_COMPRESSION: return "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden";
|
15637
15963
|
case KTO_CHECK_INVALID_COMPRESSION_LIB: return "der angegebene Wert f�r die Default-Kompression ist ung�ltig";
|
15638
15964
|
case OK_UNTERKONTO_ATTACHED: return "wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angef�gt";
|
@@ -15776,6 +16102,7 @@ DLL_EXPORT const char *kto_check_retval2dos(int retval)
|
|
15776
16102
|
DLL_EXPORT const char *kto_check_retval2html(int retval)
|
15777
16103
|
{
|
15778
16104
|
switch(retval){
|
16105
|
+
case NO_OWN_IBAN_CALCULATION: return "das Institut erlaubt keine eigene IBAN-Berechnung";
|
15779
16106
|
case KTO_CHECK_UNSUPPORTED_COMPRESSION: return "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden";
|
15780
16107
|
case KTO_CHECK_INVALID_COMPRESSION_LIB: return "der angegebene Wert für die Default-Kompression ist ungültig";
|
15781
16108
|
case OK_UNTERKONTO_ATTACHED: return "wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angefügt";
|
@@ -15919,6 +16246,7 @@ DLL_EXPORT const char *kto_check_retval2html(int retval)
|
|
15919
16246
|
DLL_EXPORT const char *kto_check_retval2utf8(int retval)
|
15920
16247
|
{
|
15921
16248
|
switch(retval){
|
16249
|
+
case NO_OWN_IBAN_CALCULATION: return "das Institut erlaubt keine eigene IBAN-Berechnung";
|
15922
16250
|
case KTO_CHECK_UNSUPPORTED_COMPRESSION: return "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden";
|
15923
16251
|
case KTO_CHECK_INVALID_COMPRESSION_LIB: return "der angegebene Wert für die Default-Kompression ist ungültig";
|
15924
16252
|
case OK_UNTERKONTO_ATTACHED: return "wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angefügt";
|
@@ -16062,6 +16390,7 @@ DLL_EXPORT const char *kto_check_retval2utf8(int retval)
|
|
16062
16390
|
DLL_EXPORT const char *kto_check_retval2txt_short(int retval)
|
16063
16391
|
{
|
16064
16392
|
switch(retval){
|
16393
|
+
case NO_OWN_IBAN_CALCULATION: return "NO_OWN_IBAN_CALCULATION";
|
16065
16394
|
case KTO_CHECK_UNSUPPORTED_COMPRESSION: return "KTO_CHECK_UNSUPPORTED_COMPRESSION";
|
16066
16395
|
case KTO_CHECK_INVALID_COMPRESSION_LIB: return "KTO_CHECK_INVALID_COMPRESSION_LIB";
|
16067
16396
|
case OK_UNTERKONTO_ATTACHED: return "OK_UNTERKONTO_ATTACHED";
|
@@ -16295,15 +16624,19 @@ DLL_EXPORT int get_lut_info(char **info,char *lut_name)
|
|
16295
16624
|
return OK;
|
16296
16625
|
}
|
16297
16626
|
|
16298
|
-
/* Funktion kc_free() +���1 */
|
16627
|
+
/* Funktion kc_alloc() und kc_free() +���1 */
|
16299
16628
|
/*
|
16300
16629
|
* ######################################################################
|
16301
|
-
* # kc_free(): Speicher freigeben
|
16630
|
+
* # kc_alloc und kc_free(): Speicher allokieren, bzw. freigeben #
|
16631
|
+
* # #
|
16632
|
+
* # kc_alloc wird in C# benutzt, da es so einfacher ist, Speicher zu #
|
16633
|
+
* # allokieren. #
|
16302
16634
|
* # #
|
16303
16635
|
* # Die Funktion kc_free() ruft nur free() auf; sie wird vom Perl-Modul#
|
16304
|
-
* # ben�tigt, da in KontoCheck.xs in strawberry perl (Windows)
|
16305
|
-
* # Funktion free() auf die Perl-Version umdefiniert wird und damit
|
16636
|
+
* # und C# ben�tigt, da in KontoCheck.xs in strawberry perl (Windows) #
|
16637
|
+
* # die Funktion free() auf die Perl-Version umdefiniert wird und damit#
|
16306
16638
|
* # keinen Speicher freigeben kann, der von C aus allokiert wurde. #
|
16639
|
+
* # Auch in C# ist die Speicherverwaltung nicht einfach m�glich. #
|
16307
16640
|
* # #
|
16308
16641
|
* # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
|
16309
16642
|
* ######################################################################
|
@@ -16314,6 +16647,16 @@ DLL_EXPORT void kc_free(char *ptr)
|
|
16314
16647
|
free(ptr);
|
16315
16648
|
}
|
16316
16649
|
|
16650
|
+
DLL_EXPORT void *kc_alloc(int size,int *retval)
|
16651
|
+
{
|
16652
|
+
void *ptr;
|
16653
|
+
if(!(ptr=calloc(size,1)))
|
16654
|
+
*retval=ERROR_MALLOC;
|
16655
|
+
else
|
16656
|
+
*retval=OK;
|
16657
|
+
return ptr;
|
16658
|
+
}
|
16659
|
+
|
16317
16660
|
/* Funktion cleanup_kto() +���1 */
|
16318
16661
|
/* ###########################################################################
|
16319
16662
|
* # cleanup_kto(): Speicher freigeben #
|
@@ -16468,7 +16811,7 @@ DLL_EXPORT int dump_lutfile(char *outputname,UINT4 *required)
|
|
16468
16811
|
i+=7;
|
16469
16812
|
break;
|
16470
16813
|
case 11:
|
16471
|
-
fprintf(out,"%1s ","
|
16814
|
+
fprintf(out,"%1s ","A");
|
16472
16815
|
i+=2;
|
16473
16816
|
break;
|
16474
16817
|
case 12:
|
@@ -16483,10 +16826,6 @@ DLL_EXPORT int dump_lutfile(char *outputname,UINT4 *required)
|
|
16483
16826
|
fprintf(out,"%-58s ","Name, Kurzn.");
|
16484
16827
|
i+=59;
|
16485
16828
|
break;
|
16486
|
-
case 15:
|
16487
|
-
fprintf(out,"%1s ","Infoblock");
|
16488
|
-
i+=2;
|
16489
|
-
break;
|
16490
16829
|
default:
|
16491
16830
|
break;
|
16492
16831
|
}
|
@@ -16612,7 +16951,7 @@ DLL_EXPORT int rebuild_blzfile(char *inputname,char *outputname,UINT4 set)
|
|
16612
16951
|
for(i=0;(lut_set[i+3]=lut_set_9[i]) && i<28;i++);
|
16613
16952
|
lut_set[i+3]=0;
|
16614
16953
|
if(i==100000)return FATAL_ERROR; /* keine m�gliche Ausgabedatei gefunden */
|
16615
|
-
ret=generate_lut2(inputname,tmpfile,"Testdatei
|
16954
|
+
ret=generate_lut2(inputname,tmpfile,"Testdatei fuer LUT2",NULL,lut_set,20,3,0);
|
16616
16955
|
printf("generate_lut2: %s\n",kto_check_retval2txt_short(ret));
|
16617
16956
|
if(ret!=OK){
|
16618
16957
|
unlink(tmpfile);
|
@@ -16728,6 +17067,13 @@ DLL_EXPORT const char *iban2bic(char *iban,int *retval,char *blz,char *kto)
|
|
16728
17067
|
* # zum Test der anderen IBAN-Routinen geschrieben, und sollte nicht zum #
|
16729
17068
|
* # Generieren realer IBANs benutzt werden (s.u.). #
|
16730
17069
|
* # #
|
17070
|
+
* # Update Juni 2011: #
|
17071
|
+
* # Es wird die Verbotsliste der Sparkassen ausgewertet, so da� f�r #
|
17072
|
+
* # Institute, die einer Selbstberechnung nicht zugestimmt haben, keine #
|
17073
|
+
* # IBAN berechnet wird. Damit d�rften die Berechnungen (falls die "rote #
|
17074
|
+
* # Liste" in der LUT-Datei vorhanden ist und ausgewertet wird) doch #
|
17075
|
+
* # brauchbar sein. #
|
17076
|
+
* # #
|
16731
17077
|
* # Parameter: #
|
16732
17078
|
* # blz: Bankleitzahl. Falls der Bankleitzahl ein + vorangestellt #
|
16733
17079
|
* # wird, wird die entsprechende Bankverbindung nicht auf #
|
@@ -16765,22 +17111,33 @@ DLL_EXPORT const char *iban2bic(char *iban,int *retval,char *blz,char *kto)
|
|
16765
17111
|
DLL_EXPORT char *iban_gen(char *blz,char *kto,int *retval)
|
16766
17112
|
{
|
16767
17113
|
char c,check[128],iban[128],xkto[16],*ptr,*dptr;
|
16768
|
-
int j,ret,uk_cnt=-1;
|
17114
|
+
int j,ret,uk_cnt=-1,blz_i,flags;
|
16769
17115
|
UINT4 zahl,rest;
|
16770
|
-
#if DEBUG
|
16771
|
-
RETVAL retvals;
|
16772
|
-
#endif
|
16773
17116
|
|
16774
|
-
|
16775
|
-
if(*blz=='+'
|
17117
|
+
flags=0;
|
17118
|
+
if(*blz=='+' || *(blz+1)=='+')flags=1;
|
17119
|
+
if(*blz=='@' || *(blz+1)=='@')flags+=2;
|
17120
|
+
if(flags==3)
|
17121
|
+
blz+=2;
|
17122
|
+
else if(flags)
|
16776
17123
|
blz++;
|
16777
|
-
|
16778
|
-
|
16779
|
-
|
16780
|
-
|
16781
|
-
|
16782
|
-
|
16783
|
-
|
17124
|
+
|
17125
|
+
if(!(flags&2) && own_iban){
|
17126
|
+
/* testen, ob die BLZ in der "Verbotsliste" steht */
|
17127
|
+
blz_i=atoi(blz);
|
17128
|
+
if(bsearch(&blz_i,own_iban,own_iban_cnt,sizeof(int),cmp_int)){
|
17129
|
+
if(retval)*retval=NO_OWN_IBAN_CALCULATION;
|
17130
|
+
return NULL;
|
17131
|
+
}
|
17132
|
+
}
|
17133
|
+
|
17134
|
+
/* erstmal das Konto testen */
|
17135
|
+
if(!(flags&1)){ /* kein Test */
|
17136
|
+
if((ret=kto_check_blz_x(blz,kto,&uk_cnt))<=0)
|
17137
|
+
{ /* Konto fehlerhaft */
|
17138
|
+
if(retval)*retval=ret;
|
17139
|
+
return NULL;
|
17140
|
+
}
|
16784
17141
|
}
|
16785
17142
|
if(uk_cnt>0){
|
16786
17143
|
for(ptr=kto+uk_cnt,dptr=xkto;(*dptr=*ptr++);dptr++);
|
@@ -16801,7 +17158,7 @@ DLL_EXPORT char *iban_gen(char *blz,char *kto,int *retval)
|
|
16801
17158
|
else if(uk_cnt==-1){
|
16802
17159
|
if(retval)*retval=OK_UNTERKONTO_GIVEN;
|
16803
17160
|
}
|
16804
|
-
else{
|
17161
|
+
else{ /* uk_cnt==-2 */
|
16805
17162
|
if(retval)*retval=OK;
|
16806
17163
|
}
|
16807
17164
|
|
@@ -17005,8 +17362,9 @@ DLL_EXPORT int ipi_gen(char *zweck,char *dst,char *papier)
|
|
17005
17362
|
/* der Verwendungszweck wird nun nach dst kopiert und linksb�ndig mit
|
17006
17363
|
* Nullen aufgef�llt.
|
17007
17364
|
*/
|
17008
|
-
|
17009
|
-
for(
|
17365
|
+
/* ptr auf Ende des Verwendungszwecks setzen, Zeichen testen */
|
17366
|
+
for(ptr=zweck;*ptr;ptr++)if((c=*ptr) && !(isdigit(c) || (c>='A' && c<='Z') || (c>='a' && c<='z')))return IPI_INVALID_CHARACTER;
|
17367
|
+
for(dptr=buffer+20;ptr>=zweck;*dptr--=toupper(*ptr--));
|
17010
17368
|
while(dptr>buffer)*dptr--='0';
|
17011
17369
|
|
17012
17370
|
/* Verwendungszweck nach check kopieren, dabei Buchstaben konvertieren */
|
@@ -17109,36 +17467,428 @@ DLL_EXPORT int ipi_check(char *zweck)
|
|
17109
17467
|
* # Felder der LUT-Datei, z.B. Banken in einem bestimmten Ort oder mit #
|
17110
17468
|
* # einem bestimmten Namen etc. #
|
17111
17469
|
* # #
|
17112
|
-
* # Copyright (C) 2009 Michael Plugge <m.plugge@hs-mannheim.de>
|
17470
|
+
* # Copyright (C) 2009,2011 Michael Plugge <m.plugge@hs-mannheim.de> #
|
17113
17471
|
* ###########################################################################
|
17114
17472
|
*/
|
17115
17473
|
|
17116
|
-
/* Funktion
|
17117
|
-
/*
|
17118
|
-
*
|
17119
|
-
*
|
17474
|
+
/* Funktion get_sortc() +���2 */
|
17475
|
+
/* Diese Funktion holt einen "Buchstaben" aus einem String und gibt eine auf
|
17476
|
+
* 12 Bit erweiterte Form zur�ck, bei denen Gro�- und Kleinbuchstaben als
|
17477
|
+
* gleich angesehen werden und akzentuierte Buchstaben nach den
|
17478
|
+
* Grundbuchstaben eingereiht werden (allerdings von diesen unterschieden
|
17479
|
+
* werden, anders als bis Version 3.6 von konto_check). F�r UTF-8 sowie
|
17480
|
+
* HTML-kodierte Zeichenfolgen werden die entsprechenden Sequenzen ebenfalls
|
17481
|
+
* erkannt und der Eingangspointer dann entsprechend modifiziert zur�ckgegeben.
|
17120
17482
|
*/
|
17121
|
-
static
|
17483
|
+
static int get_sortc(char **a,int enc)
|
17122
17484
|
{
|
17123
|
-
|
17124
|
-
|
17485
|
+
unsigned char *p,*ptr;
|
17486
|
+
int base,accent;
|
17487
|
+
|
17488
|
+
ptr=(unsigned char*)*a;
|
17489
|
+
accent=0;
|
17490
|
+
switch(base=*ptr++){
|
17491
|
+
|
17492
|
+
/* Gro�buchstaben: */
|
17493
|
+
case 'A': base='a'; break;
|
17494
|
+
case 'B': base='b'; break;
|
17495
|
+
case 'C': base='c'; break;
|
17496
|
+
case 'D': base='d'; break;
|
17497
|
+
case 'E': base='e'; break;
|
17498
|
+
case 'F': base='f'; break;
|
17499
|
+
case 'G': base='g'; break;
|
17500
|
+
case 'H': base='h'; break;
|
17501
|
+
case 'I': base='i'; break;
|
17502
|
+
case 'J': base='j'; break;
|
17503
|
+
case 'K': base='k'; break;
|
17504
|
+
case 'L': base='l'; break;
|
17505
|
+
case 'M': base='m'; break;
|
17506
|
+
case 'N': base='n'; break;
|
17507
|
+
case 'O': base='o'; break;
|
17508
|
+
case 'P': base='p'; break;
|
17509
|
+
case 'Q': base='q'; break;
|
17510
|
+
case 'R': base='r'; break;
|
17511
|
+
case 'S': base='s'; break;
|
17512
|
+
case 'T': base='t'; break;
|
17513
|
+
case 'U': base='u'; break;
|
17514
|
+
case 'V': base='v'; break;
|
17515
|
+
case 'W': base='w'; break;
|
17516
|
+
case 'X': base='x'; break;
|
17517
|
+
case 'Y': base='y'; break;
|
17518
|
+
case 'Z': base='z'; break;
|
17519
|
+
|
17520
|
+
/* DOS CP-850 und Kollisionen mit ISO-8859-1 */
|
17521
|
+
case 0xa0: base='a'; accent=1; break; /* CP-850: � a acute */
|
17522
|
+
case 0x83: base='a'; accent=2; break; /* CP-850: � a circ */
|
17523
|
+
case 0x85: base='a'; accent=3; break; /* CP-850: � a grave */
|
17524
|
+
case 0xc6: base='a'; accent=4; break; /* CP-850: � a tilde */
|
17525
|
+
case 0x84: base='a'; accent=5; break; /* CP-850: � a uml */
|
17526
|
+
case 0xb5: base='a'; accent=1; break; /* CP-850: � A acute */
|
17527
|
+
case 0xb6: base='a'; accent=2; break; /* CP-850: � A circ */
|
17528
|
+
case 0xb7: base='a'; accent=3; break; /* CP-850: � A grave */
|
17529
|
+
case 0xc7: base='a'; accent=4; break; /* CP-850: � A tilde */
|
17530
|
+
case 0x8e: base='a'; accent=5; break; /* CP-850: � A uml */
|
17531
|
+
case 0x82: base='e'; accent=1; break; /* CP-850: � e acute */
|
17532
|
+
case 0x88: base='e'; accent=2; break; /* CP-850: � e circ */
|
17533
|
+
case 0x8a: base='e'; accent=3; break; /* CP-850: � e grave */
|
17534
|
+
case 0x89: base='e'; accent=5; break; /* CP-850: � e uml */
|
17535
|
+
case 0x90: base='e'; accent=1; break; /* CP-850: � E acute */
|
17536
|
+
case 0xd2:
|
17537
|
+
if(enc==4){
|
17538
|
+
base='e'; accent=2; break; /* CP-850: � E circ */
|
17539
|
+
}
|
17540
|
+
else{
|
17541
|
+
base='o'; accent=3; break; /* ISO-8859-1: � O grave */
|
17542
|
+
}
|
17543
|
+
case 0xd4:
|
17544
|
+
if(enc==4){
|
17545
|
+
base='e'; accent=3; break; /* CP-850: � E grave */
|
17546
|
+
}
|
17547
|
+
else{
|
17548
|
+
base='o'; accent=2; break; /* ISO-8859-1: � O circ */
|
17549
|
+
}
|
17550
|
+
case 0xd3:
|
17551
|
+
if(enc==4){
|
17552
|
+
base='e'; accent=5; break; /* CP-850: � E uml */
|
17553
|
+
}
|
17554
|
+
else{
|
17555
|
+
base='o'; accent=1; break; /* ISO-8859-1: � O acute */
|
17556
|
+
}
|
17557
|
+
case 0xa1: base='i'; accent=1; break; /* CP-850: � i acute */
|
17558
|
+
case 0x8c: base='i'; accent=2; break; /* CP-850: � i circ */
|
17559
|
+
case 0x8d: base='i'; accent=3; break; /* CP-850: � i grave */
|
17560
|
+
case 0x8b: base='i'; accent=5; break; /* CP-850: � i uml */
|
17561
|
+
case 0xd6:
|
17562
|
+
if(enc==4){
|
17563
|
+
base='i'; accent=1; break; /* CP-850: � I acute */
|
17564
|
+
}
|
17565
|
+
else{
|
17566
|
+
base='o'; accent=5; break; /* ISO-8859-1: � O uml */
|
17567
|
+
}
|
17568
|
+
case 0xd7: base='i'; accent=2; break; /* CP-850: � I circ */
|
17569
|
+
case 0xde: base='i'; accent=3; break; /* CP-850: � I grave */
|
17570
|
+
case 0xd8: base='i'; accent=5; break; /* CP-850: � I uml */
|
17571
|
+
case 0xa4: base='n'; accent=4; break; /* CP-850: � n tilde */
|
17572
|
+
case 0xa5: base='n'; accent=4; break; /* CP-850: � N tilde */
|
17573
|
+
case 0xa2: base='o'; accent=1; break; /* CP-850: � o acute */
|
17574
|
+
case 0x93: base='o'; accent=2; break; /* CP-850: � o circ */
|
17575
|
+
case 0x95: base='o'; accent=3; break; /* CP-850: � o grave */
|
17576
|
+
case 0xe4:
|
17577
|
+
if(enc==4){
|
17578
|
+
base='o'; accent=4; break; /* CP-850: � o tilde */
|
17579
|
+
}
|
17580
|
+
else{
|
17581
|
+
base='a'; accent=5; break; /* ISO-8859-1: � a uml */
|
17582
|
+
}
|
17583
|
+
case 0x94: base='o'; accent=5; break; /* CP-850: � o uml */
|
17584
|
+
case 0xe0:
|
17585
|
+
if(enc==4){
|
17586
|
+
base='o'; accent=1; break; /* CP-850: � O acute */
|
17587
|
+
}
|
17588
|
+
else{
|
17589
|
+
base='a'; accent=3; break; /* ISO-8859-1: � a grave */
|
17590
|
+
}
|
17591
|
+
case 0xe2:
|
17592
|
+
if(enc==4){
|
17593
|
+
base='o'; accent=2; break; /* CP-850: � O circ */
|
17594
|
+
}
|
17595
|
+
else{
|
17596
|
+
base='a'; accent=2; break; /* ISO-8859-1: � a circ */
|
17597
|
+
}
|
17598
|
+
case 0xe3:
|
17599
|
+
if(enc==4){
|
17600
|
+
base='o'; accent=3; break; /* CP-850: � O grave */
|
17601
|
+
}
|
17602
|
+
else{
|
17603
|
+
base='a'; accent=4; break; /* ISO-8859-1: � a tilde */
|
17604
|
+
}
|
17605
|
+
case 0xe5: base='o'; accent=4; break; /* CP-850: � O tilde */
|
17606
|
+
case 0x99: base='o'; accent=5; break; /* CP-850: � O uml */
|
17607
|
+
case 0xa3: base='u'; accent=1; break; /* CP-850: � u acute */
|
17608
|
+
case 0x96: base='u'; accent=2; break; /* CP-850: � u circ */
|
17609
|
+
case 0x97: base='u'; accent=3; break; /* CP-850: � u grave */
|
17610
|
+
case 0x81: base='u'; accent=5; break; /* CP-850: � u uml */
|
17611
|
+
case 0xe9:
|
17612
|
+
if(enc==4){
|
17613
|
+
base='u'; accent=1; break; /* CP-850: � U acute */
|
17614
|
+
}
|
17615
|
+
else{
|
17616
|
+
base='e'; accent=1; break; /* ISO-8859-1: � e acute */
|
17617
|
+
}
|
17618
|
+
case 0xea:
|
17619
|
+
if(enc==4){
|
17620
|
+
base='u'; accent=2; break; /* CP-850: � U circ */
|
17621
|
+
}
|
17622
|
+
else{
|
17623
|
+
base='e'; accent=2; break; /* ISO-8859-1: � e circ */
|
17624
|
+
}
|
17625
|
+
case 0xeb:
|
17626
|
+
if(enc==4){
|
17627
|
+
base='u'; accent=3; break; /* CP-850: � U grave */
|
17628
|
+
}
|
17629
|
+
else{
|
17630
|
+
base='e'; accent=5; break; /* ISO-8859-1: � e uml */
|
17631
|
+
}
|
17632
|
+
case 0x9a: base='u'; accent=5; break; /* CP-850: � U uml */
|
17633
|
+
case 0xec:
|
17634
|
+
if(enc==4){
|
17635
|
+
base='y'; accent=1; break; /* CP-850: � y acute */
|
17636
|
+
}
|
17637
|
+
else{
|
17638
|
+
base='i'; accent=3; break; /* ISO-8859-1: � i grave */
|
17639
|
+
}
|
17640
|
+
case 0xed:
|
17641
|
+
if(enc==4){
|
17642
|
+
base='y'; accent=1; break; /* CP-850: � Y acute */
|
17643
|
+
}
|
17644
|
+
else{
|
17645
|
+
base='i'; accent=1; break; /* ISO-8859-1: � i acute */
|
17646
|
+
}
|
17647
|
+
case 0x98: base='y'; accent=5; break; /* CP-850: � y uml */
|
17648
|
+
case 0xe1:
|
17649
|
+
if(enc==4){
|
17650
|
+
base='s'; accent=1; break; /* CP-850: � s szlig */
|
17651
|
+
}
|
17652
|
+
else{
|
17653
|
+
base='a'; accent=1; break; /* ISO-8859-1: � a acute */
|
17654
|
+
}
|
17655
|
+
|
17656
|
+
|
17657
|
+
/* ISO-8859-1 */
|
17658
|
+
case 0xc1: base='a'; accent=1; break; /* ISO-8859-1: � A acute */
|
17659
|
+
case 0xc2: base='a'; accent=2; break; /* ISO-8859-1: � A circ */
|
17660
|
+
case 0xc0: base='a'; accent=3; break; /* ISO-8859-1: � A grave */
|
17661
|
+
case 0xc4: base='a'; accent=5; break; /* ISO-8859-1: � A uml */
|
17662
|
+
case 0xe8: base='e'; accent=3; break; /* ISO-8859-1: � e grave */
|
17663
|
+
case 0xc9: base='e'; accent=1; break; /* ISO-8859-1: � E acute */
|
17664
|
+
case 0xca: base='e'; accent=2; break; /* ISO-8859-1: � E circ */
|
17665
|
+
case 0xc8: base='e'; accent=3; break; /* ISO-8859-1: � E grave */
|
17666
|
+
case 0xcb: base='e'; accent=5; break; /* ISO-8859-1: � E uml */
|
17667
|
+
case 0xee: base='i'; accent=2; break; /* ISO-8859-1: � i circ */
|
17668
|
+
case 0xef: base='i'; accent=5; break; /* ISO-8859-1: � i uml */
|
17669
|
+
case 0xcd: base='i'; accent=1; break; /* ISO-8859-1: � I acute */
|
17670
|
+
case 0xce: base='i'; accent=2; break; /* ISO-8859-1: � I circ */
|
17671
|
+
case 0xcc: base='i'; accent=3; break; /* ISO-8859-1: � I grave */
|
17672
|
+
case 0xcf: base='i'; accent=5; break; /* ISO-8859-1: � I uml */
|
17673
|
+
case 0xf1: base='n'; accent=4; break; /* ISO-8859-1: � n tilde */
|
17674
|
+
case 0xd1: base='n'; accent=4; break; /* ISO-8859-1: � N tilde */
|
17675
|
+
case 0xf3: base='o'; accent=1; break; /* ISO-8859-1: � o acute */
|
17676
|
+
case 0xf4: base='o'; accent=2; break; /* ISO-8859-1: � o circ */
|
17677
|
+
case 0xf2: base='o'; accent=3; break; /* ISO-8859-1: � o grave */
|
17678
|
+
case 0xf5: base='o'; accent=4; break; /* ISO-8859-1: � o tilde */
|
17679
|
+
case 0xf6: base='o'; accent=5; break; /* ISO-8859-1: � o uml */
|
17680
|
+
case 0xd5: base='o'; accent=4; break; /* ISO-8859-1: � O tilde */
|
17681
|
+
case 0xfa: base='u'; accent=1; break; /* ISO-8859-1: � u acute */
|
17682
|
+
case 0xfb: base='u'; accent=2; break; /* ISO-8859-1: � u circ */
|
17683
|
+
case 0xf9: base='u'; accent=3; break; /* ISO-8859-1: � u grave */
|
17684
|
+
case 0xfc: base='u'; accent=5; break; /* ISO-8859-1: � u uml */
|
17685
|
+
case 0xda: base='u'; accent=1; break; /* ISO-8859-1: � U acute */
|
17686
|
+
case 0xdb: base='u'; accent=2; break; /* ISO-8859-1: � U circ */
|
17687
|
+
case 0xd9: base='u'; accent=3; break; /* ISO-8859-1: � U grave */
|
17688
|
+
case 0xdc: base='u'; accent=5; break; /* ISO-8859-1: � U uml */
|
17689
|
+
case 0xfd: base='y'; accent=1; break; /* ISO-8859-1: � Y acute */
|
17690
|
+
case 0xdd: base='y'; accent=1; break; /* ISO-8859-1: � Y acute */
|
17691
|
+
case 0xff: base='y'; accent=5; break; /* ISO-8859-1: � y uml */
|
17692
|
+
case 0xdf: base='s'; accent=1; break; /* ISO-8859-1: � s szlig */
|
17693
|
+
|
17694
|
+
|
17695
|
+
case 0xc3: /* UTF-8 Zeichen */
|
17696
|
+
switch(*ptr){
|
17697
|
+
|
17698
|
+
/* UTF8-Kodierung (immer mit Pr�fix 0xc3): */
|
17699
|
+
case 0xa1: ptr++; base='a'; accent=1; break; /* UTF-8: á a acute */
|
17700
|
+
case 0xa2: ptr++; base='a'; accent=2; break; /* UTF-8: â a circ */
|
17701
|
+
case 0xa0: ptr++; base='a'; accent=3; break; /* UTF-8: à a grave */
|
17702
|
+
case 0xa3: ptr++; base='a'; accent=4; break; /* UTF-8: ã a tilde */
|
17703
|
+
case 0xa4: ptr++; base='a'; accent=5; break; /* UTF-8: ä a uml */
|
17704
|
+
case 0X81: ptr++; base='a'; accent=1; break; /* UTF-8: Á A acute */
|
17705
|
+
case 0X82: ptr++; base='a'; accent=2; break; /* UTF-8: Â A circ */
|
17706
|
+
case 0X80: ptr++; base='a'; accent=3; break; /* UTF-8: À A grave */
|
17707
|
+
case 0X83: ptr++; base='a'; accent=4; break; /* UTF-8: Ã A tilde */
|
17708
|
+
case 0X84: ptr++; base='a'; accent=5; break; /* UTF-8: Ä A uml */
|
17709
|
+
case 0xa9: ptr++; base='e'; accent=1; break; /* UTF-8: é e acute */
|
17710
|
+
case 0xaa: ptr++; base='e'; accent=2; break; /* UTF-8: ê e circ */
|
17711
|
+
case 0xa8: ptr++; base='e'; accent=3; break; /* UTF-8: è e grave */
|
17712
|
+
case 0xab: ptr++; base='e'; accent=5; break; /* UTF-8: ë e uml */
|
17713
|
+
case 0x89: ptr++; base='e'; accent=1; break; /* UTF-8: É E acute */
|
17714
|
+
case 0x8a: ptr++; base='e'; accent=2; break; /* UTF-8: Ê E circ */
|
17715
|
+
case 0x88: ptr++; base='e'; accent=3; break; /* UTF-8: È E grave */
|
17716
|
+
case 0x8b: ptr++; base='e'; accent=5; break; /* UTF-8: Ë E uml */
|
17717
|
+
case 0xad: ptr++; base='i'; accent=1; break; /* UTF-8: í i acute */
|
17718
|
+
case 0xae: ptr++; base='i'; accent=2; break; /* UTF-8: î i circ */
|
17719
|
+
case 0xac: ptr++; base='i'; accent=3; break; /* UTF-8: ì i grave */
|
17720
|
+
case 0xaf: ptr++; base='i'; accent=5; break; /* UTF-8: ï i uml */
|
17721
|
+
case 0x8d: ptr++; base='i'; accent=1; break; /* UTF-8: Í I acute */
|
17722
|
+
case 0x8e: ptr++; base='i'; accent=2; break; /* UTF-8: Î I circ */
|
17723
|
+
case 0x8c: ptr++; base='i'; accent=3; break; /* UTF-8: Ì I grave */
|
17724
|
+
case 0x8f: ptr++; base='i'; accent=5; break; /* UTF-8: Ï I uml */
|
17725
|
+
case 0xb1: ptr++; base='n'; accent=4; break; /* UTF-8: ñ n tilde */
|
17726
|
+
case 0x91: ptr++; base='n'; accent=4; break; /* UTF-8: Ñ N tilde */
|
17727
|
+
case 0xb3: ptr++; base='o'; accent=1; break; /* UTF-8: ó o acute */
|
17728
|
+
case 0xb4: ptr++; base='o'; accent=2; break; /* UTF-8: ô o circ */
|
17729
|
+
case 0xb2: ptr++; base='o'; accent=3; break; /* UTF-8: ò o grave */
|
17730
|
+
case 0xb5: ptr++; base='o'; accent=4; break; /* UTF-8: õ o tilde */
|
17731
|
+
case 0xb6: ptr++; base='o'; accent=5; break; /* UTF-8: ö o uml */
|
17732
|
+
case 0x93: ptr++; base='o'; accent=1; break; /* UTF-8: Ó O acute */
|
17733
|
+
case 0x94: ptr++; base='o'; accent=2; break; /* UTF-8: Ô O circ */
|
17734
|
+
case 0x92: ptr++; base='o'; accent=3; break; /* UTF-8: Ò O grave */
|
17735
|
+
case 0x95: ptr++; base='o'; accent=4; break; /* UTF-8: Õ O tilde */
|
17736
|
+
case 0x96: ptr++; base='o'; accent=5; break; /* UTF-8: Ö O uml */
|
17737
|
+
case 0xba: ptr++; base='u'; accent=1; break; /* UTF-8: ú u acute */
|
17738
|
+
case 0xbb: ptr++; base='u'; accent=2; break; /* UTF-8: û u circ */
|
17739
|
+
case 0xb9: ptr++; base='u'; accent=3; break; /* UTF-8: ù u grave */
|
17740
|
+
case 0xbc: ptr++; base='u'; accent=5; break; /* UTF-8: ü u uml */
|
17741
|
+
case 0x9a: ptr++; base='u'; accent=1; break; /* UTF-8: Ú U acute */
|
17742
|
+
case 0x9b: ptr++; base='u'; accent=2; break; /* UTF-8: Û U circ */
|
17743
|
+
case 0x99: ptr++; base='u'; accent=3; break; /* UTF-8: Ù U grave */
|
17744
|
+
case 0x9c: ptr++; base='u'; accent=5; break; /* UTF-8: Ü U uml */
|
17745
|
+
case 0xbd: ptr++; base='y'; accent=1; break; /* UTF-8: ý y acute */
|
17746
|
+
case 0x9d: ptr++; base='y'; accent=1; break; /* UTF-8: Ý Y acute */
|
17747
|
+
case 0xbf: ptr++; base='y'; accent=5; break; /* UTF-8: ÿ y uml */
|
17748
|
+
case 0x9f: ptr++; base='s'; accent=1; break; /* UTF-8: ß szlig */
|
17749
|
+
default: /* m�glicherweise ISO-8859-1 */
|
17750
|
+
base='a'; accent=4; break; /* ISO-8859-1: � A tilde */
|
17751
|
+
}
|
17752
|
+
break;
|
17753
|
+
|
17754
|
+
case '&':
|
17755
|
+
/* testen auf einige HTML Entities. Die folgenden Entities werden behandelt:
|
17756
|
+
* &[aAoOuUiIeEy]uml;
|
17757
|
+
* &[aAoOuUiIeEy]acute;
|
17758
|
+
* &[aAoOuUiIeE]grave;
|
17759
|
+
* &[aAoOuUiIeEn]tilde;
|
17760
|
+
* &[aAoOuUiIeE]circ;
|
17761
|
+
* ß
|
17762
|
+
* "
|
17763
|
+
* &
|
17764
|
+
* <
|
17765
|
+
* >
|
17766
|
+
* &#xxx; der obigen Entities (numerisch)
|
17767
|
+
*/
|
17768
|
+
p=ptr+1; if(*p++=='u' && *p++=='m' && *p++=='l' && *p++==';') {base=tolower(*ptr); accent=5; ptr=p; break;}
|
17769
|
+
p=ptr+1; if(*p++=='a' && *p++=='c' && *p++=='u' && *p++=='t' && *p++=='e' && *p++==';'){base=tolower(*ptr); accent=1; ptr=p; break;}
|
17770
|
+
p=ptr+1; if(*p++=='g' && *p++=='r' && *p++=='a' && *p++=='v' && *p++=='e' && *p++==';'){base=tolower(*ptr); accent=3; ptr=p; break;}
|
17771
|
+
p=ptr+1; if(*p++=='t' && *p++=='i' && *p++=='l' && *p++=='d' && *p++=='e' && *p++==';'){base=tolower(*ptr); accent=4; ptr=p; break;}
|
17772
|
+
p=ptr+1; if(*p++=='c' && *p++=='i' && *p++=='r' && *p++=='c' && *p++==';') {base=tolower(*ptr); accent=2; ptr=p; break;}
|
17773
|
+
p=ptr+1; if(*ptr=='s' && *p++=='z' && *p++=='l' && *p++=='i' && *p++=='g' && *p++==';'){base='s'; accent=1; ptr=p; break;}
|
17774
|
+
p=ptr; if(*p++=='q' && *p++=='u' && *p++=='o' && *p++=='t' && *p++==';') {base='\"';ptr=p; break;}
|
17775
|
+
p=ptr; if(*p++=='a' && *p++=='m' && *p++=='p' && *p++==';') {base='&'; ptr=p; break;}
|
17776
|
+
p=ptr; if(*p++=='l' && *p++=='t' && *p++==';') {base='<'; ptr=p; break;}
|
17777
|
+
p=ptr; if(*p++=='g' && *p++=='t' && *p++==';') {base='>'; ptr=p; break;}
|
17778
|
+
|
17779
|
+
/* numerische Escape-Sequenzen */
|
17780
|
+
p=ptr+1;
|
17781
|
+
if(*ptr=='#' && *(p+3)==';'){
|
17782
|
+
switch(atoi((char*)p)){
|
17783
|
+
case 224: base='a'; accent=3; ptr=p+4; break;
|
17784
|
+
case 225: base='a'; accent=1; ptr=p+4; break;
|
17785
|
+
case 226: base='a'; accent=2; ptr=p+4; break;
|
17786
|
+
case 227: base='a'; accent=4; ptr=p+4; break;
|
17787
|
+
case 228: base='a'; accent=5; ptr=p+4; break;
|
17788
|
+
case 192: base='a'; accent=3; ptr=p+4; break;
|
17789
|
+
case 193: base='a'; accent=1; ptr=p+4; break;
|
17790
|
+
case 194: base='a'; accent=2; ptr=p+4; break;
|
17791
|
+
case 195: base='a'; accent=4; ptr=p+4; break;
|
17792
|
+
case 196: base='a'; accent=5; ptr=p+4; break;
|
17793
|
+
case 232: base='e'; accent=3; ptr=p+4; break;
|
17794
|
+
case 233: base='e'; accent=1; ptr=p+4; break;
|
17795
|
+
case 234: base='e'; accent=2; ptr=p+4; break;
|
17796
|
+
case 235: base='e'; accent=5; ptr=p+4; break;
|
17797
|
+
case 200: base='e'; accent=3; ptr=p+4; break;
|
17798
|
+
case 201: base='e'; accent=1; ptr=p+4; break;
|
17799
|
+
case 202: base='e'; accent=2; ptr=p+4; break;
|
17800
|
+
case 203: base='e'; accent=5; ptr=p+4; break;
|
17801
|
+
case 236: base='i'; accent=3; ptr=p+4; break;
|
17802
|
+
case 237: base='i'; accent=1; ptr=p+4; break;
|
17803
|
+
case 238: base='i'; accent=2; ptr=p+4; break;
|
17804
|
+
case 239: base='i'; accent=5; ptr=p+4; break;
|
17805
|
+
case 204: base='i'; accent=3; ptr=p+4; break;
|
17806
|
+
case 205: base='i'; accent=1; ptr=p+4; break;
|
17807
|
+
case 206: base='i'; accent=2; ptr=p+4; break;
|
17808
|
+
case 207: base='i'; accent=5; ptr=p+4; break;
|
17809
|
+
case 209: base='n'; accent=4; ptr=p+4; break;
|
17810
|
+
case 241: base='n'; accent=4; ptr=p+4; break;
|
17811
|
+
case 242: base='o'; accent=3; ptr=p+4; break;
|
17812
|
+
case 243: base='o'; accent=1; ptr=p+4; break;
|
17813
|
+
case 244: base='o'; accent=2; ptr=p+4; break;
|
17814
|
+
case 245: base='o'; accent=4; ptr=p+4; break;
|
17815
|
+
case 246: base='o'; accent=5; ptr=p+4; break;
|
17816
|
+
case 210: base='o'; accent=3; ptr=p+4; break;
|
17817
|
+
case 211: base='o'; accent=1; ptr=p+4; break;
|
17818
|
+
case 212: base='o'; accent=2; ptr=p+4; break;
|
17819
|
+
case 213: base='o'; accent=4; ptr=p+4; break;
|
17820
|
+
case 214: base='o'; accent=5; ptr=p+4; break;
|
17821
|
+
case 249: base='u'; accent=3; ptr=p+4; break;
|
17822
|
+
case 250: base='u'; accent=1; ptr=p+4; break;
|
17823
|
+
case 251: base='u'; accent=2; ptr=p+4; break;
|
17824
|
+
case 252: base='u'; accent=5; ptr=p+4; break;
|
17825
|
+
case 217: base='u'; accent=3; ptr=p+4; break;
|
17826
|
+
case 218: base='u'; accent=1; ptr=p+4; break;
|
17827
|
+
case 219: base='u'; accent=2; ptr=p+4; break;
|
17828
|
+
case 220: base='u'; accent=5; ptr=p+4; break;
|
17829
|
+
case 223: base='s'; accent=1; ptr=p+4; break;
|
17830
|
+
case 221: base='y'; accent=1; ptr=p+4; break;
|
17831
|
+
case 253: base='y'; accent=1; ptr=p+4; break;
|
17832
|
+
case 255: base='y'; accent=5; ptr=p+4; break;
|
17833
|
+
default: break;
|
17834
|
+
}
|
17835
|
+
break;
|
17836
|
+
}
|
17837
|
+
if(*ptr=='#' && *(p+2)==';'){
|
17838
|
+
switch(atoi((char*)p)){
|
17839
|
+
case 34: base='\"'; ptr=p+3; break;
|
17840
|
+
case 38: base='&'; ptr=p+3; break;
|
17841
|
+
case 60: base='<'; ptr=p+3; break;
|
17842
|
+
case 62: base='>'; ptr=p+3; break;
|
17843
|
+
}
|
17844
|
+
break;
|
17845
|
+
}
|
17846
|
+
break; /* keine bekannte Escapesequenz gefunden; weitermachen */
|
17847
|
+
|
17848
|
+
default: break; /* sonstiges Zeichen, direkt verarbeiten */
|
17849
|
+
}
|
17850
|
+
*a=(char*)ptr;
|
17851
|
+
return base*16+accent;
|
17852
|
+
}
|
17853
|
+
|
17854
|
+
/* Funktion stri_cmp() +���3 */
|
17855
|
+
/* diese Funktion �hnelt wie strcasecmp(): strcmp ohne Gro�/Kleinschreibung,
|
17856
|
+
* dazu werden noch die Umlaute ber�cksichtigt (diese werden bei den
|
17857
|
+
* entsprechenden Grundbuchstaben einsortiert). Die Umlaute werden in der
|
17858
|
+
* Funktion get_sortc() behandelt. Seit der Version 3.7 werden alle
|
17859
|
+
* Kodierungen (inklusive UTF-8 und HTML Entities) ber�cksichtigt; vorher
|
17860
|
+
* war die Behandlung der Umlaute auf ISO-8859-1 beschr�nkt).
|
17861
|
+
*/
|
17862
|
+
static int stri_cmp(char *a,char *b)
|
17863
|
+
{
|
17864
|
+
int ac,bc,enc;
|
17865
|
+
|
17866
|
+
ac=bc=0;
|
17867
|
+
enc=current_encoding%10;
|
17868
|
+
while((ac=get_sortc(&a,enc))==(bc=get_sortc(&b,enc)) && ac);
|
17869
|
+
return ac-bc;
|
17125
17870
|
}
|
17126
17871
|
|
17127
|
-
/* Funktion strni_cmp() +���
|
17872
|
+
/* Funktion strni_cmp() +���3 */
|
17128
17873
|
/* Diese Funktion entspricht weitgehend der vorhergehenden (stri_cmp());
|
17129
17874
|
* falls der String a k�rzer ist als b und soweit mit b �bereinstimmt, wird
|
17130
17875
|
* allerdings "gleich" (0) zur�ckgegeben. Diese Funktion wird zum Vergleich
|
17131
|
-
* bei der Suche nach Orten oder
|
17876
|
+
* bei der Suche nach Orten oder Banknamen benutzt.
|
17132
17877
|
*/
|
17133
|
-
static
|
17134
|
-
|
17135
|
-
|
17136
|
-
|
17878
|
+
static int strni_cmp(char *a,char *b)
|
17879
|
+
{
|
17880
|
+
int ac,bc,enc;
|
17881
|
+
|
17882
|
+
ac=bc=0;
|
17883
|
+
enc=current_encoding%10;
|
17884
|
+
while((ac=get_sortc(&a,enc))==(bc=get_sortc(&b,enc)) && ac);
|
17885
|
+
if(ac)
|
17886
|
+
return ac-bc;
|
17137
17887
|
else
|
17138
17888
|
return 0;
|
17139
17889
|
}
|
17140
17890
|
|
17141
|
-
/* Funktion binary_search_int() +���
|
17891
|
+
/* Funktion binary_search_int() +���3 */
|
17142
17892
|
static int binary_search_int(int a1,int a2,int *base,int *sort_a,int cnt,int *unten,int *anzahl)
|
17143
17893
|
{
|
17144
17894
|
int x,y,l,r;
|
@@ -17165,12 +17915,20 @@ static int binary_search_int(int a1,int a2,int *base,int *sort_a,int cnt,int *un
|
|
17165
17915
|
return OK;
|
17166
17916
|
}
|
17167
17917
|
|
17168
|
-
/* Funktion binary_search() +���
|
17918
|
+
/* Funktion binary_search() +���3 */
|
17169
17919
|
static int binary_search(char *a,char **base,int *sort_a,int cnt,int *unten,int *anzahl)
|
17170
17920
|
{
|
17171
17921
|
int x,y,l,r;
|
17922
|
+
int (*fkt)(char*,char*);
|
17172
17923
|
|
17173
|
-
|
17924
|
+
if(*a=='!'){ /* bei Suchaufrufen mit ! als erstem Zeichen -> genaue Suche starten */
|
17925
|
+
a++;
|
17926
|
+
fkt=stri_cmp;
|
17927
|
+
}
|
17928
|
+
else
|
17929
|
+
fkt=strni_cmp;
|
17930
|
+
|
17931
|
+
for(l=0,r=cnt-1,x=(l+r)/2;(y=(*fkt)(a,base[sort_a[x]])) && y && l<r;){
|
17174
17932
|
if(y<0)
|
17175
17933
|
r=x-1;
|
17176
17934
|
else
|
@@ -17182,18 +17940,44 @@ static int binary_search(char *a,char **base,int *sort_a,int cnt,int *unten,int
|
|
17182
17940
|
return KEY_NOT_FOUND;
|
17183
17941
|
}
|
17184
17942
|
|
17185
|
-
for(l=x;l>=0 && !
|
17943
|
+
for(l=x;l>=0 && !(*fkt)(a,base[sort_a[l]]);l--);
|
17186
17944
|
l++;
|
17187
17945
|
*unten=l;
|
17188
17946
|
|
17189
|
-
for(r=x;r<cnt && !
|
17947
|
+
for(r=x;r<cnt && !(*fkt)(a,base[sort_a[r]]);r++);
|
17190
17948
|
r--;
|
17191
17949
|
*anzahl=r-l+1;
|
17192
17950
|
return OK;
|
17193
17951
|
}
|
17194
17952
|
|
17953
|
+
/* Funktion qcmp_sorti() +���3 */
|
17954
|
+
static int qcmp_sorti(const void *ap,const void *bp)
|
17955
|
+
{
|
17956
|
+
int a,b,r;
|
17957
|
+
|
17958
|
+
a=*((int *)ap);
|
17959
|
+
b=*((int *)bp);
|
17960
|
+
if((r=sorti_buf[a]-sorti_buf[b]))
|
17961
|
+
return r;
|
17962
|
+
else
|
17963
|
+
return a-b;
|
17964
|
+
}
|
17965
|
+
|
17966
|
+
/* Funktion qcmp_sortc() +���3 */
|
17967
|
+
static int qcmp_sortc(const void *ap,const void *bp)
|
17968
|
+
{
|
17969
|
+
int a,b,r;
|
17970
|
+
|
17971
|
+
a=*((int *)ap);
|
17972
|
+
b=*((int *)bp);
|
17973
|
+
if((r=stri_cmp(sortc_buf[a],sortc_buf[b])))
|
17974
|
+
return r;
|
17975
|
+
else
|
17976
|
+
return a-b;
|
17977
|
+
}
|
17978
|
+
|
17195
17979
|
|
17196
|
-
/* Funktion qcmp_bic() +���
|
17980
|
+
/* Funktion qcmp_bic() +���3 */
|
17197
17981
|
static int qcmp_bic(const void *ap,const void *bp)
|
17198
17982
|
{
|
17199
17983
|
int a,b,r;
|
@@ -17206,7 +17990,7 @@ static int qcmp_bic(const void *ap,const void *bp)
|
|
17206
17990
|
return a-b;
|
17207
17991
|
}
|
17208
17992
|
|
17209
|
-
/* Funktion qcmp_name() +���
|
17993
|
+
/* Funktion qcmp_name() +���3 */
|
17210
17994
|
static int qcmp_name(const void *ap,const void *bp)
|
17211
17995
|
{
|
17212
17996
|
int a,b,r;
|
@@ -17219,7 +18003,7 @@ static int qcmp_name(const void *ap,const void *bp)
|
|
17219
18003
|
return a-b;
|
17220
18004
|
}
|
17221
18005
|
|
17222
|
-
/* Funktion qcmp_name_kurz() +���
|
18006
|
+
/* Funktion qcmp_name_kurz() +���3 */
|
17223
18007
|
static int qcmp_name_kurz(const void *ap,const void *bp)
|
17224
18008
|
{
|
17225
18009
|
int a,b,r;
|
@@ -17232,7 +18016,7 @@ static int qcmp_name_kurz(const void *ap,const void *bp)
|
|
17232
18016
|
return a-b;
|
17233
18017
|
}
|
17234
18018
|
|
17235
|
-
/* Funktion qcmp_ort() +���
|
18019
|
+
/* Funktion qcmp_ort() +���3 */
|
17236
18020
|
static int qcmp_ort(const void *ap,const void *bp)
|
17237
18021
|
{
|
17238
18022
|
int a,b,r;
|
@@ -17245,7 +18029,7 @@ static int qcmp_ort(const void *ap,const void *bp)
|
|
17245
18029
|
return a-b;
|
17246
18030
|
}
|
17247
18031
|
|
17248
|
-
/* Funktion qcmp_blz() +���
|
18032
|
+
/* Funktion qcmp_blz() +���3 */
|
17249
18033
|
static int qcmp_blz(const void *ap,const void *bp)
|
17250
18034
|
{
|
17251
18035
|
int a,b,r;
|
@@ -17258,7 +18042,7 @@ static int qcmp_blz(const void *ap,const void *bp)
|
|
17258
18042
|
return a-b;
|
17259
18043
|
}
|
17260
18044
|
|
17261
|
-
/* Funktion qcmp_pz_methoden() +���
|
18045
|
+
/* Funktion qcmp_pz_methoden() +���3 */
|
17262
18046
|
static int qcmp_pz_methoden(const void *ap,const void *bp)
|
17263
18047
|
{
|
17264
18048
|
int a,b,r;
|
@@ -17271,7 +18055,7 @@ static int qcmp_pz_methoden(const void *ap,const void *bp)
|
|
17271
18055
|
return a-b;
|
17272
18056
|
}
|
17273
18057
|
|
17274
|
-
/* Funktion qcmp_plz() +���
|
18058
|
+
/* Funktion qcmp_plz() +���3 */
|
17275
18059
|
static int qcmp_plz(const void *ap,const void *bp)
|
17276
18060
|
{
|
17277
18061
|
int a,b,r;
|
@@ -17284,37 +18068,15 @@ static int qcmp_plz(const void *ap,const void *bp)
|
|
17284
18068
|
return a-b;
|
17285
18069
|
}
|
17286
18070
|
|
17287
|
-
/* Funktion
|
17288
|
-
|
17289
|
-
|
17290
|
-
|
17291
|
-
|
17292
|
-
|
17293
|
-
if(!a2)a2=a1;
|
17294
|
-
b_sort=*base_sort;
|
17295
|
-
if(!b_sort){
|
17296
|
-
if(!(b_sort=calloc(cnt+10,sizeof(int))))return ERROR_MALLOC;
|
17297
|
-
*base_sort=b_sort; /* Variable an aufrufende Funktion zur�ckgeben */
|
17298
|
-
for(i=0;i<cnt;i++)b_sort[i]=i;
|
17299
|
-
qsort(b_sort,cnt,sizeof(int),cmp);
|
17300
|
-
}
|
17301
|
-
if((retval=binary_search_int(a1,a2,*base_name,b_sort,cnt,&unten,&cnt))!=OK){
|
17302
|
-
if(anzahl)*anzahl=0;
|
17303
|
-
if(start_idx)*start_idx=NULL;
|
17304
|
-
return retval;
|
17305
|
-
}
|
17306
|
-
if(anzahl)*anzahl=cnt;
|
17307
|
-
if(start_idx)*start_idx=b_sort+unten;
|
17308
|
-
return OK;
|
17309
|
-
}
|
17310
|
-
|
17311
|
-
/* Funktion suche_int2() +���2 */
|
17312
|
-
static int suche_int2(int a1,int a2,int *anzahl,int **start_idx,int **zweigstelle,int **blz_base,
|
17313
|
-
int **base_name,int **base_sort,int(*cmp)(const void *, const void *))
|
18071
|
+
/* Funktion init_blzf() +���2
|
18072
|
+
* Diese Funktion initialisiert das Array mit den Bankleitzahlen f�r alle
|
18073
|
+
* Indizes (blz_f) und das Zweigstellen-Array (f�r Index -> Zweigstelle).
|
18074
|
+
*/
|
18075
|
+
static int init_blzf(int *cnt_p)
|
17314
18076
|
{
|
17315
|
-
int i,j,
|
18077
|
+
int cnt,i,j,n,k;
|
17316
18078
|
|
17317
|
-
if(
|
18079
|
+
if(cnt_p)*cnt_p=0;
|
17318
18080
|
if(startidx[lut2_cnt_hs-1]==lut2_cnt_hs-1){ /* keine Filialen in der Datei enthalten */
|
17319
18081
|
cnt=lut2_cnt_hs;
|
17320
18082
|
blz_f=blz; /* die einfache BLZ-Tabelle reicht aus */
|
@@ -17343,73 +18105,182 @@ static int suche_int2(int a1,int a2,int *anzahl,int **start_idx,int **zweigstell
|
|
17343
18105
|
blz_f[j++]=blz[i];
|
17344
18106
|
}
|
17345
18107
|
}
|
18108
|
+
if(cnt_p)*cnt_p=cnt;
|
18109
|
+
return OK;
|
18110
|
+
}
|
18111
|
+
|
18112
|
+
DLL_EXPORT int konto_check_idx2blz(int idx,int *zweigstelle,int *retval)
|
18113
|
+
{
|
18114
|
+
int ret;
|
18115
|
+
if(!blz_f && (ret=init_blzf(NULL))<0){
|
18116
|
+
*retval=ret;
|
18117
|
+
*zweigstelle=0;
|
18118
|
+
return 0;
|
18119
|
+
}
|
18120
|
+
*retval=OK;
|
18121
|
+
*zweigstelle=zweigstelle_f[idx];
|
18122
|
+
return blz_f[idx];
|
18123
|
+
}
|
18124
|
+
|
18125
|
+
/* Funktion suche_int1() +���2 */
|
18126
|
+
static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstelle_base,int **blz_base,
|
18127
|
+
int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int cnt,int such_idx)
|
18128
|
+
{
|
18129
|
+
char *data,*ptr;
|
18130
|
+
const char *lut_name;
|
18131
|
+
int i,cnt1,unten,retval,*b_sort,lut_set;
|
18132
|
+
UINT4 len;
|
18133
|
+
|
18134
|
+
if(!a2)a2=a1;
|
17346
18135
|
b_sort=*base_sort;
|
17347
18136
|
if(!b_sort){
|
17348
|
-
|
17349
|
-
|
17350
|
-
|
17351
|
-
else
|
17352
|
-
blz_f=NULL;
|
18137
|
+
lut_name=current_lutfile_name(&lut_set,NULL,&retval);
|
18138
|
+
if(retval!=OK){ /* nicht initialisiert */
|
18139
|
+
FREE(blz_f);
|
17353
18140
|
FREE(zweigstelle_f);
|
17354
|
-
return
|
18141
|
+
return retval;
|
18142
|
+
}
|
18143
|
+
/* versuchen, den Indexblock aus der LUT-Datei zu lesen */
|
18144
|
+
if(lut_set==2)such_idx+=100;
|
18145
|
+
retval=read_lut_block((char*)lut_name,such_idx,&len,&data);
|
18146
|
+
if(retval==OK){
|
18147
|
+
ptr=data;
|
18148
|
+
C2UI(cnt1,ptr);
|
18149
|
+
if(!(b_sort=malloc(cnt1*sizeof(int)))){
|
18150
|
+
FREE(blz_f);
|
18151
|
+
FREE(zweigstelle_f);
|
18152
|
+
return ERROR_MALLOC;
|
18153
|
+
}
|
18154
|
+
for(i=0;i<cnt1;i++)C2UI(b_sort[i],ptr);
|
18155
|
+
free(data);
|
18156
|
+
}
|
18157
|
+
else{
|
18158
|
+
/* Indexblock nicht gefunden, Index jetzt aufbauen */
|
18159
|
+
if(!(b_sort=calloc(cnt+10,sizeof(int))))return ERROR_MALLOC;
|
18160
|
+
for(i=0;i<cnt;i++)b_sort[i]=i;
|
18161
|
+
qsort(b_sort,cnt,sizeof(int),cmp);
|
17355
18162
|
}
|
17356
18163
|
*base_sort=b_sort; /* Variable an aufrufende Funktion zur�ckgeben */
|
17357
|
-
for(i=0;i<cnt;i++)b_sort[i]=i;
|
17358
|
-
qsort(b_sort,cnt,sizeof(int),cmp);
|
17359
18164
|
}
|
17360
18165
|
if((retval=binary_search_int(a1,a2,*base_name,b_sort,cnt,&unten,&cnt))!=OK){
|
17361
18166
|
if(anzahl)*anzahl=0;
|
17362
18167
|
if(start_idx)*start_idx=NULL;
|
17363
|
-
|
18168
|
+
return retval;
|
17364
18169
|
}
|
17365
|
-
if(blz_base)*blz_base=blz_f;
|
17366
|
-
if(zweigstelle)*zweigstelle=zweigstelle_f;
|
17367
18170
|
if(anzahl)*anzahl=cnt;
|
17368
18171
|
if(start_idx)*start_idx=b_sort+unten;
|
17369
18172
|
return OK;
|
17370
18173
|
}
|
17371
18174
|
|
17372
|
-
/* Funktion
|
17373
|
-
static int
|
17374
|
-
|
18175
|
+
/* Funktion suche_int2() +���2 */
|
18176
|
+
static int suche_int2(int a1,int a2,int *anzahl,int **start_idx,int **zweigstelle_base,int **blz_base,
|
18177
|
+
int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int such_idx)
|
17375
18178
|
{
|
17376
|
-
|
18179
|
+
char *data,*ptr;
|
18180
|
+
const char *lut_name;
|
18181
|
+
int i,cnt,unten,retval,*b_sort,lut_set;
|
18182
|
+
UINT4 len;
|
17377
18183
|
|
17378
|
-
if(
|
17379
|
-
|
17380
|
-
|
17381
|
-
|
17382
|
-
|
17383
|
-
|
17384
|
-
if(!blz_f){ /* Bankleitzahlen mit Filialen; eigenes Array erforderlich */
|
17385
|
-
if(!(blz_f=calloc(cnt+10,sizeof(int))))return ERROR_MALLOC;
|
17386
|
-
if(!(zweigstelle_f=calloc(cnt+10,sizeof(int)))){
|
18184
|
+
if(!a2)a2=a1;
|
18185
|
+
if((retval=init_blzf(&cnt))<0)return retval;
|
18186
|
+
b_sort=*base_sort;
|
18187
|
+
if(!b_sort){
|
18188
|
+
lut_name=current_lutfile_name(&lut_set,NULL,&retval);
|
18189
|
+
if(retval!=OK){ /* nicht initialisiert */
|
17387
18190
|
FREE(blz_f);
|
17388
|
-
|
18191
|
+
FREE(zweigstelle_f);
|
18192
|
+
return retval;
|
17389
18193
|
}
|
17390
|
-
|
17391
|
-
|
17392
|
-
|
17393
|
-
|
18194
|
+
/* versuchen, den Indexblock aus der LUT-Datei zu lesen */
|
18195
|
+
if(lut_set==2)such_idx+=100;
|
18196
|
+
retval=read_lut_block((char*)lut_name,such_idx,&len,&data);
|
18197
|
+
if(retval==OK){
|
18198
|
+
ptr=data;
|
18199
|
+
C2UI(cnt,ptr);
|
18200
|
+
if(!(b_sort=malloc(cnt*sizeof(int)))){
|
18201
|
+
if(blz_f!=blz)
|
18202
|
+
FREE(blz_f);
|
18203
|
+
else
|
18204
|
+
blz_f=NULL;
|
18205
|
+
FREE(zweigstelle_f);
|
18206
|
+
return ERROR_MALLOC;
|
17394
18207
|
}
|
18208
|
+
for(i=0;i<cnt;i++)C2UI(b_sort[i],ptr);
|
18209
|
+
free(data);
|
17395
18210
|
}
|
17396
18211
|
else{
|
17397
|
-
|
17398
|
-
|
18212
|
+
/* Indexblock nicht gefunden, Index jetzt aufbauen */
|
18213
|
+
if(!(b_sort=calloc(cnt+10,sizeof(int)))){
|
18214
|
+
if(blz_f!=blz)
|
18215
|
+
FREE(blz_f);
|
18216
|
+
else
|
18217
|
+
blz_f=NULL;
|
18218
|
+
FREE(zweigstelle_f);
|
18219
|
+
return ERROR_MALLOC;
|
18220
|
+
}
|
18221
|
+
for(i=0;i<cnt;i++)b_sort[i]=i;
|
18222
|
+
qsort(b_sort,cnt,sizeof(int),cmp);
|
17399
18223
|
}
|
18224
|
+
*base_sort=b_sort; /* Variable an aufrufende Funktion zur�ckgeben */
|
18225
|
+
}
|
18226
|
+
if((retval=binary_search_int(a1,a2,*base_name,b_sort,cnt,&unten,&cnt))!=OK){
|
18227
|
+
if(anzahl)*anzahl=0;
|
18228
|
+
if(start_idx)*start_idx=NULL;
|
18229
|
+
RETURN(retval);
|
17400
18230
|
}
|
17401
18231
|
if(blz_base)*blz_base=blz_f;
|
17402
|
-
if(
|
18232
|
+
if(zweigstelle_base)*zweigstelle_base=zweigstelle_f;
|
18233
|
+
if(anzahl)*anzahl=cnt;
|
18234
|
+
if(start_idx)*start_idx=b_sort+unten;
|
18235
|
+
return OK;
|
18236
|
+
}
|
18237
|
+
|
18238
|
+
/* Funktion suche_str() +���2 */
|
18239
|
+
static int suche_str(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,int **blz_base,
|
18240
|
+
char ***base_name,int **base_sort,int(*cmp)(const void *, const void *),UINT4 such_idx)
|
18241
|
+
{
|
18242
|
+
char *data,*ptr;
|
18243
|
+
const char *lut_name;
|
18244
|
+
int i,cnt,unten,retval,*b_sort,lut_set;
|
18245
|
+
UINT4 len;
|
18246
|
+
|
18247
|
+
if((retval=init_blzf(&cnt))<0)return retval;
|
18248
|
+
if(blz_base)*blz_base=blz_f;
|
18249
|
+
if(zweigstelle_base)*zweigstelle_base=zweigstelle_f;
|
17403
18250
|
b_sort=*base_sort;
|
17404
18251
|
if(!b_sort){
|
17405
|
-
|
18252
|
+
/* Dateinamen und Set der aktuellen Initialisierung holen */
|
18253
|
+
lut_name=current_lutfile_name(&lut_set,NULL,&retval);
|
18254
|
+
if(retval!=OK){ /* nicht initialisiert */
|
17406
18255
|
FREE(blz_f);
|
17407
18256
|
FREE(zweigstelle_f);
|
17408
|
-
return
|
18257
|
+
return retval;
|
18258
|
+
}
|
18259
|
+
/* versuchen, den Indexblock aus der LUT-Datei zu lesen */
|
18260
|
+
if(lut_set==2)such_idx+=100;
|
18261
|
+
retval=read_lut_block((char*)lut_name,such_idx,&len,&data);
|
18262
|
+
if(retval==OK){
|
18263
|
+
ptr=data;
|
18264
|
+
C2UI(cnt,ptr);
|
18265
|
+
if(!(b_sort=malloc(cnt*sizeof(int)))){
|
18266
|
+
FREE(blz_f);
|
18267
|
+
FREE(zweigstelle_f);
|
18268
|
+
return ERROR_MALLOC;
|
18269
|
+
}
|
18270
|
+
for(i=0;i<cnt;i++)C2UI(b_sort[i],ptr);
|
18271
|
+
free(data);
|
18272
|
+
}
|
18273
|
+
else{
|
18274
|
+
/* Indexblock nicht gefunden, Index jetzt aufbauen */
|
18275
|
+
if(!(b_sort=calloc(cnt+10,sizeof(int)))){
|
18276
|
+
FREE(blz_f);
|
18277
|
+
FREE(zweigstelle_f);
|
18278
|
+
return ERROR_MALLOC;
|
18279
|
+
}
|
18280
|
+
for(i=0;i<cnt;i++)b_sort[i]=i;
|
18281
|
+
qsort(b_sort,cnt,sizeof(int),cmp);
|
17409
18282
|
}
|
17410
18283
|
*base_sort=b_sort; /* Variable an aufrufende Funktion zur�ckgeben */
|
17411
|
-
for(i=0;i<cnt;i++)b_sort[i]=i;
|
17412
|
-
qsort(b_sort,cnt,sizeof(int),cmp);
|
17413
18284
|
}
|
17414
18285
|
while(isspace(*such_name))such_name++;
|
17415
18286
|
if((retval=binary_search(such_name,*base_name,b_sort,cnt,&unten,&cnt))!=OK){
|
@@ -17423,7 +18294,7 @@ static int suche_str(char *such_name,int *anzahl,int **start_idx,int **zweigstel
|
|
17423
18294
|
}
|
17424
18295
|
|
17425
18296
|
/* Funktion lut_suche_bic() +���2 */
|
17426
|
-
DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **
|
18297
|
+
DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,
|
17427
18298
|
char ***base_name,int **blz_base)
|
17428
18299
|
{
|
17429
18300
|
if(anzahl)*anzahl=0;
|
@@ -17431,11 +18302,11 @@ DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **z
|
|
17431
18302
|
if(lut_id_status==FALSE)return LUT1_FILE_USED;
|
17432
18303
|
if(!bic)return LUT2_BIC_NOT_INITIALIZED;
|
17433
18304
|
if(base_name)*base_name=bic;
|
17434
|
-
return suche_str(such_name,anzahl,start_idx,
|
18305
|
+
return suche_str(such_name,anzahl,start_idx,zweigstelle_base,blz_base,&bic,&sort_bic,qcmp_bic,LUT2_BIC_SORT);
|
17435
18306
|
}
|
17436
18307
|
|
17437
18308
|
/* Funktion lut_suche_namen() +���2 */
|
17438
|
-
DLL_EXPORT int lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int **
|
18309
|
+
DLL_EXPORT int lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,
|
17439
18310
|
char ***base_name,int **blz_base)
|
17440
18311
|
{
|
17441
18312
|
if(anzahl)*anzahl=0;
|
@@ -17443,11 +18314,11 @@ DLL_EXPORT int lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int *
|
|
17443
18314
|
if(lut_id_status==FALSE)return LUT1_FILE_USED;
|
17444
18315
|
if(!name)return LUT2_NAME_NOT_INITIALIZED;
|
17445
18316
|
if(base_name)*base_name=name;
|
17446
|
-
return suche_str(such_name,anzahl,start_idx,
|
18317
|
+
return suche_str(such_name,anzahl,start_idx,zweigstelle_base,blz_base,&name,&sort_name,qcmp_name,LUT2_NAME_SORT);
|
17447
18318
|
}
|
17448
18319
|
|
17449
18320
|
/* Funktion lut_suche_namen_kurz() +���2 */
|
17450
|
-
DLL_EXPORT int lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,int **
|
18321
|
+
DLL_EXPORT int lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,
|
17451
18322
|
char ***base_name,int **blz_base)
|
17452
18323
|
{
|
17453
18324
|
if(anzahl)*anzahl=0;
|
@@ -17455,11 +18326,11 @@ DLL_EXPORT int lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,
|
|
17455
18326
|
if(lut_id_status==FALSE)return LUT1_FILE_USED;
|
17456
18327
|
if(!name_kurz)return LUT2_NAME_KURZ_NOT_INITIALIZED;
|
17457
18328
|
if(base_name)*base_name=name_kurz;
|
17458
|
-
return suche_str(such_name,anzahl,start_idx,
|
18329
|
+
return suche_str(such_name,anzahl,start_idx,zweigstelle_base,blz_base,&name_kurz,&sort_name_kurz,qcmp_name_kurz,LUT2_NAME_KURZ_SORT);
|
17459
18330
|
}
|
17460
18331
|
|
17461
18332
|
/* Funktion lut_suche_ort() +���2 */
|
17462
|
-
DLL_EXPORT int lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **
|
18333
|
+
DLL_EXPORT int lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,
|
17463
18334
|
char ***base_name,int **blz_base)
|
17464
18335
|
{
|
17465
18336
|
if(anzahl)*anzahl=0;
|
@@ -17467,11 +18338,11 @@ DLL_EXPORT int lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **z
|
|
17467
18338
|
if(lut_id_status==FALSE)return LUT1_FILE_USED;
|
17468
18339
|
if(!ort)return LUT2_ORT_NOT_INITIALIZED;
|
17469
18340
|
if(base_name)*base_name=ort;
|
17470
|
-
return suche_str(such_name,anzahl,start_idx,
|
18341
|
+
return suche_str(such_name,anzahl,start_idx,zweigstelle_base,blz_base,&ort,&sort_ort,qcmp_ort,LUT2_ORT_SORT);
|
17471
18342
|
}
|
17472
18343
|
|
17473
18344
|
/* Funktion lut_suche_blz() +���2 */
|
17474
|
-
DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int **
|
18345
|
+
DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base)
|
17475
18346
|
{
|
17476
18347
|
int cnt;
|
17477
18348
|
|
@@ -17482,16 +18353,16 @@ DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int
|
|
17482
18353
|
if(base_name)*base_name=blz;
|
17483
18354
|
cnt=lut2_cnt_hs;
|
17484
18355
|
if(blz_base)*blz_base=blz;
|
17485
|
-
if(
|
18356
|
+
if(zweigstelle_base){
|
17486
18357
|
/* Dummy-Array f�r die Zweigstellen anlegen (nur Nullen; f�r die R�ckgabe erforderlich) */
|
17487
18358
|
if(!zweigstelle_f1 && !(zweigstelle_f1=calloc(cnt+10,sizeof(int))))return ERROR_MALLOC;
|
17488
|
-
*
|
18359
|
+
*zweigstelle_base=zweigstelle_f1;
|
17489
18360
|
}
|
17490
|
-
return suche_int1(such1,such2,anzahl,start_idx,
|
18361
|
+
return suche_int1(such1,such2,anzahl,start_idx,zweigstelle_base,blz_base,&blz,&sort_blz,qcmp_blz,cnt,0);
|
17491
18362
|
}
|
17492
18363
|
|
17493
18364
|
/* Funktion lut_suche_pz() +���2 */
|
17494
|
-
DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **
|
18365
|
+
DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base)
|
17495
18366
|
{
|
17496
18367
|
int cnt;
|
17497
18368
|
|
@@ -17502,16 +18373,16 @@ DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int
|
|
17502
18373
|
if(base_name)*base_name=pz_methoden;
|
17503
18374
|
cnt=lut2_cnt_hs;
|
17504
18375
|
if(blz_base)*blz_base=blz;
|
17505
|
-
if(
|
18376
|
+
if(zweigstelle_base){
|
17506
18377
|
/* Dummy-Array f�r die Zweigstellen anlegen (nur Nullen; f�r die R�ckgabe erforderlich) */
|
17507
18378
|
if(!zweigstelle_f1 && !(zweigstelle_f1=calloc(cnt+10,sizeof(int))))return ERROR_MALLOC;
|
17508
|
-
*
|
18379
|
+
*zweigstelle_base=zweigstelle_f1;
|
17509
18380
|
}
|
17510
|
-
return suche_int1(such1,such2,anzahl,start_idx,
|
18381
|
+
return suche_int1(such1,such2,anzahl,start_idx,zweigstelle_base,blz_base,&pz_methoden,&sort_pz_methoden,qcmp_pz_methoden,cnt,LUT2_PZ_SORT);
|
17511
18382
|
}
|
17512
18383
|
|
17513
18384
|
/* Funktion lut_suche_plz() +���2 */
|
17514
|
-
DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **
|
18385
|
+
DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base)
|
17515
18386
|
{
|
17516
18387
|
if(anzahl)*anzahl=0;
|
17517
18388
|
if(such2 && such1>such2)return INVALID_SEARCH_RANGE;
|
@@ -17519,7 +18390,7 @@ DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int
|
|
17519
18390
|
if(lut_id_status==FALSE)return LUT1_FILE_USED;
|
17520
18391
|
if(!plz)return LUT2_PLZ_NOT_INITIALIZED;
|
17521
18392
|
if(base_name)*base_name=plz;
|
17522
|
-
return suche_int2(such1,such2,anzahl,start_idx,
|
18393
|
+
return suche_int2(such1,such2,anzahl,start_idx,zweigstelle_base,blz_base,&plz,&sort_plz,qcmp_plz,LUT2_PLZ_SORT);
|
17523
18394
|
}
|
17524
18395
|
|
17525
18396
|
|
@@ -17796,6 +18667,381 @@ DLL_EXPORT int kto_check_write_default(char *lutfile,int block_id)
|
|
17796
18667
|
free(buffer);
|
17797
18668
|
}
|
17798
18669
|
|
18670
|
+
/* Funktion kto_check_encoding() +���1 */
|
18671
|
+
/* ###########################################################################
|
18672
|
+
* # Diese Funktion setzt die Kodierung f�r die konto_check Bibliothek fest. #
|
18673
|
+
* # Es wird sowohl die Kodierung f�r die Fehlermeldungen als auch die der #
|
18674
|
+
* # LUT-Datei gesetzt. Innerhalb der LUT-Datei sind die Werte im Format #
|
18675
|
+
* # ISO-8859-1 gespeichert; sie werden bei der Initialisierung konvertiert. #
|
18676
|
+
* # #
|
18677
|
+
* # F�r den Parameter mode werden die folgenden Werte akzeptiert: #
|
18678
|
+
* # 1,'i','I': ISO-8859-1 #
|
18679
|
+
* # 2,'u','U': UTF-8 #
|
18680
|
+
* # 3,'h','H': HTML-Entities #
|
18681
|
+
* # 4,'d','D': DOS (CP850) #
|
18682
|
+
* # 51 Fehlermeldungen als Makronamen, Rest in ISO-8859-1 #
|
18683
|
+
* # 52 Fehlermeldungen als Makronamen, Rest in UTF-8 #
|
18684
|
+
* # 53 Fehlermeldungen als Makronamen, Rest in HTML-Entities #
|
18685
|
+
* # 54 Fehlermeldungen als Makronamen, Rest in DOS (CP850) #
|
18686
|
+
* # #
|
18687
|
+
* # R�ckgabewert ist der aktuell gesetzte Modus (als Zahl). Falls die #
|
18688
|
+
* # Funktion mit dem Parameter 0 aufgerufen wird, wird nur die aktuelle #
|
18689
|
+
* # Kodierung zur�ckgegeben. #
|
18690
|
+
* # #
|
18691
|
+
* # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
|
18692
|
+
* ###########################################################################
|
18693
|
+
*/
|
18694
|
+
|
18695
|
+
DLL_EXPORT int kto_check_encoding(int mode)
|
18696
|
+
{
|
18697
|
+
char *ptr,*data,*eptr,*hs=NULL;
|
18698
|
+
int lut_encoding,i,retval;
|
18699
|
+
UINT4 len;
|
18700
|
+
|
18701
|
+
lut_encoding=encoding%10;
|
18702
|
+
switch(mode){
|
18703
|
+
case 1:
|
18704
|
+
case 'i':
|
18705
|
+
case 'I':
|
18706
|
+
encoding=1;
|
18707
|
+
current_encoding=current_encoding%10+10;
|
18708
|
+
retval_enc=kto_check_retval2iso;
|
18709
|
+
break;
|
18710
|
+
|
18711
|
+
case 2:
|
18712
|
+
case 'u':
|
18713
|
+
case 'U':
|
18714
|
+
encoding=2;
|
18715
|
+
current_encoding=current_encoding%10+20;
|
18716
|
+
retval_enc=kto_check_retval2utf8;
|
18717
|
+
break;
|
18718
|
+
|
18719
|
+
case 3:
|
18720
|
+
case 'h':
|
18721
|
+
case 'H':
|
18722
|
+
encoding=3;
|
18723
|
+
current_encoding=current_encoding%10+30;
|
18724
|
+
retval_enc=kto_check_retval2html;
|
18725
|
+
break;
|
18726
|
+
|
18727
|
+
case 4:
|
18728
|
+
case 'd':
|
18729
|
+
case 'D':
|
18730
|
+
encoding=4;
|
18731
|
+
current_encoding=current_encoding%10+40;
|
18732
|
+
retval_enc=kto_check_retval2dos;
|
18733
|
+
break;
|
18734
|
+
|
18735
|
+
case 'm':
|
18736
|
+
case 'M':
|
18737
|
+
case 51:
|
18738
|
+
encoding=51;
|
18739
|
+
current_encoding=current_encoding%10+50;
|
18740
|
+
retval_enc=kto_check_retval2txt_short;
|
18741
|
+
break;
|
18742
|
+
|
18743
|
+
case 52:
|
18744
|
+
encoding=52;
|
18745
|
+
current_encoding=current_encoding%10+50;
|
18746
|
+
retval_enc=kto_check_retval2txt_short;
|
18747
|
+
break;
|
18748
|
+
|
18749
|
+
case 53:
|
18750
|
+
encoding=53;
|
18751
|
+
current_encoding=current_encoding%10+50;
|
18752
|
+
retval_enc=kto_check_retval2txt_short;
|
18753
|
+
break;
|
18754
|
+
|
18755
|
+
case 54:
|
18756
|
+
encoding=54;
|
18757
|
+
current_encoding=current_encoding%10+50;
|
18758
|
+
retval_enc=kto_check_retval2txt_short;
|
18759
|
+
break;
|
18760
|
+
}
|
18761
|
+
if(keep_raw_data_flag && lut_encoding!=encoding%10){ /* falls notwendig, die LUT-Blocks neu kodieren */
|
18762
|
+
if(name_raw && name_data){
|
18763
|
+
|
18764
|
+
/* bei alter Kodierung mit ISO 8859-1 (d.h. name_raw==name_data)
|
18765
|
+
* name_data nicht freigeben, sonst sind auch die raw Daten weg!!!
|
18766
|
+
*/
|
18767
|
+
if(name_raw!=name_data)FREE(name_data);
|
18768
|
+
FREE(sort_name); /* Sortierarray freigeben */
|
18769
|
+
name_data=name_raw;
|
18770
|
+
len=name_raw_len;
|
18771
|
+
data=name_raw;
|
18772
|
+
if((retval=convert_encoding(&data,&len))<=0)return retval;
|
18773
|
+
for(i=0,name_data=ptr=data,eptr=data+len;ptr<eptr && i<lut2_cnt;i++){
|
18774
|
+
if(*ptr==1)
|
18775
|
+
hs=name[i]=++ptr;
|
18776
|
+
else if(*ptr)
|
18777
|
+
name[i]=ptr;
|
18778
|
+
else
|
18779
|
+
name[i]=hs;
|
18780
|
+
while(*ptr++ && ptr<eptr);
|
18781
|
+
}
|
18782
|
+
}
|
18783
|
+
if(name_kurz_raw && name_kurz_data){
|
18784
|
+
if(name_kurz_raw!=name_kurz_data)FREE(name_kurz_data);
|
18785
|
+
FREE(sort_name_kurz);
|
18786
|
+
name_kurz_data=name_kurz_raw;
|
18787
|
+
len=name_kurz_raw_len;
|
18788
|
+
data=name_kurz_raw;
|
18789
|
+
if((retval=convert_encoding(&data,&len))<=0)return retval;
|
18790
|
+
for(i=0,name_kurz_data=ptr=data,eptr=data+len;ptr<eptr && i<lut2_cnt;i++){
|
18791
|
+
name_kurz[i]=ptr;
|
18792
|
+
while(*ptr++ && ptr<eptr);
|
18793
|
+
}
|
18794
|
+
}
|
18795
|
+
if(name_name_kurz_raw && name_name_kurz_data){
|
18796
|
+
if(name_name_kurz_raw!=name_name_kurz_data)FREE(name_name_kurz_data);
|
18797
|
+
FREE(sort_name);
|
18798
|
+
FREE(sort_name_kurz);
|
18799
|
+
name_name_kurz_data=name_name_kurz_raw;
|
18800
|
+
len=name_name_kurz_raw_len;
|
18801
|
+
data=name_name_kurz_raw;
|
18802
|
+
if((retval=convert_encoding(&data,&len))<=0)return retval;
|
18803
|
+
for(i=0,name_name_kurz_data=ptr=data,eptr=data+len;ptr<eptr && i<lut2_cnt;i++){
|
18804
|
+
if(*ptr==1)
|
18805
|
+
hs=name[i]=++ptr;
|
18806
|
+
else if(*ptr)
|
18807
|
+
name[i]=ptr;
|
18808
|
+
else
|
18809
|
+
name[i]=hs;
|
18810
|
+
while(ptr<eptr && *ptr++);
|
18811
|
+
name_kurz[i]=ptr;
|
18812
|
+
while(ptr<eptr && *ptr++);
|
18813
|
+
}
|
18814
|
+
}
|
18815
|
+
if(ort_raw && ort_data){
|
18816
|
+
if(ort_raw!=ort_data)FREE(ort_data);
|
18817
|
+
FREE(sort_ort);
|
18818
|
+
ort_data=ort_raw;
|
18819
|
+
len=ort_raw_len;
|
18820
|
+
data=ort_raw;
|
18821
|
+
if((retval=convert_encoding(&data,&len))<=0)return retval;
|
18822
|
+
for(i=0,ort_data=ptr=data,eptr=data+len;ptr<eptr && i<lut2_cnt;i++){
|
18823
|
+
ort[i]=ptr;
|
18824
|
+
while(*ptr++ && ptr<eptr);
|
18825
|
+
}
|
18826
|
+
}
|
18827
|
+
}
|
18828
|
+
if(current_encoding<50 && (current_encoding%10==current_encoding/10 || !(current_encoding%10)
|
18829
|
+
|| (!name_data && !name_kurz_data && ! name_name_kurz_data && !ort_data)))
|
18830
|
+
current_encoding/=10;
|
18831
|
+
return current_encoding;
|
18832
|
+
}
|
18833
|
+
|
18834
|
+
/* Funktion kto_check_encoding_str() +���1 */
|
18835
|
+
/* ###########################################################################
|
18836
|
+
* # Diese Funktion entspricht der Funktion kto_check_encoding(); allerdings #
|
18837
|
+
* # ist der R�ckgabewert nicht numerisch, sondern ein String. #
|
18838
|
+
* # #
|
18839
|
+
* # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
|
18840
|
+
* ###########################################################################
|
18841
|
+
*/
|
18842
|
+
|
18843
|
+
DLL_EXPORT const char *kto_check_encoding_str(int mode)
|
18844
|
+
{
|
18845
|
+
switch(kto_check_encoding(mode)){
|
18846
|
+
case 0: return "noch nicht spezifiziert";
|
18847
|
+
|
18848
|
+
case 1:
|
18849
|
+
case 11: return "ISO-8859-1";
|
18850
|
+
case 2:
|
18851
|
+
case 22: return "UTF-8";
|
18852
|
+
case 3:
|
18853
|
+
case 33: return "HTML entities";
|
18854
|
+
case 4:
|
18855
|
+
case 44: return "DOS CP-850";
|
18856
|
+
|
18857
|
+
case 21: return "UTF-8/ISO-8859-1";
|
18858
|
+
case 31: return "HTML entities/ISO-8859-1";
|
18859
|
+
case 41: return "DOS CP-850/ISO-8859-1";
|
18860
|
+
|
18861
|
+
case 12: return "ISO-8859-1/UTF-8";
|
18862
|
+
case 32: return "HTML entities/UTF-8";
|
18863
|
+
case 42: return "DOS CP-850/UTF-8";
|
18864
|
+
|
18865
|
+
case 13: return "ISO-8859-1/HTML";
|
18866
|
+
case 23: return "UTF-8/HTML";
|
18867
|
+
case 43: return "DOS CP-850/HTML";
|
18868
|
+
|
18869
|
+
case 14: return "ISO-8859-1/DOS CP 850";
|
18870
|
+
case 24: return "UTF-8/DOS CP-850";
|
18871
|
+
case 34: return "HTML entities/DOS CP-850";
|
18872
|
+
|
18873
|
+
case 51: return "Makro/ISO-8859-1";
|
18874
|
+
case 52: return "Makro/UTF-8";
|
18875
|
+
case 53: return "Makro/HTML";
|
18876
|
+
case 54: return "Makro/DOS CP-850";
|
18877
|
+
|
18878
|
+
default: return "Unbekannte Kodierung";
|
18879
|
+
}
|
18880
|
+
}
|
18881
|
+
|
18882
|
+
/* Funktion keep_raw_data() +���1 */
|
18883
|
+
/* ###########################################################################
|
18884
|
+
* # Diese Funktion setzt oder l�scht das Flag keep_raw_data_flag. Das Flag #
|
18885
|
+
* # legt fest, ob die raw-Daten der Lut-Blocks Name, Kurzname und Ort .#
|
18886
|
+
* # gespeichert werden sollen; falls ja, werden sie bei einem Wechsel der #
|
18887
|
+
* # Kodierung auch umkodiert, falls nein, ist das nicht m�glich. Die #
|
18888
|
+
* # Speicherung der raw-Daten ben�tigt etwa 900 KB an Hauptspeicher. Einige #
|
18889
|
+
* # Anmerkungen zu dem Flag finden sich auch oben bei der Deklaration von #
|
18890
|
+
* # current_encoding etc. #
|
18891
|
+
* # #
|
18892
|
+
* # M�gliche Werte f�r den Funktionsparameter mode: #
|
18893
|
+
* # 1: Flag setzen #
|
18894
|
+
* # 0: Flag abfragen, nicht ver�ndern #
|
18895
|
+
* # -1: Flag l�schen, Speicher der raw-Daten freigeben #
|
18896
|
+
* # #
|
18897
|
+
* # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
|
18898
|
+
* ###########################################################################
|
18899
|
+
*/
|
18900
|
+
|
18901
|
+
DLL_EXPORT int keep_raw_data(int mode)
|
18902
|
+
{
|
18903
|
+
if(mode==1)
|
18904
|
+
keep_raw_data_flag=1;
|
18905
|
+
else if(mode==-1){
|
18906
|
+
/* Speicher f�r die raw-Daten wieder freigeben */
|
18907
|
+
keep_raw_data_flag=0;
|
18908
|
+
if(name_raw!=name_data)
|
18909
|
+
FREE(name_raw);
|
18910
|
+
else
|
18911
|
+
name_raw=NULL;
|
18912
|
+
if(name_kurz_raw!=name_kurz_data)
|
18913
|
+
FREE(name_kurz_raw);
|
18914
|
+
else
|
18915
|
+
name_kurz_raw=NULL;
|
18916
|
+
if(name_name_kurz_raw!=name_name_kurz_data)
|
18917
|
+
FREE(name_name_kurz_raw);
|
18918
|
+
else
|
18919
|
+
name_name_kurz_raw=NULL;
|
18920
|
+
if(ort_raw!=ort_data)
|
18921
|
+
FREE(ort_raw);
|
18922
|
+
else
|
18923
|
+
ort_raw=NULL;
|
18924
|
+
name_raw_len=name_kurz_raw_len=name_name_kurz_raw_len=ort_raw_len=0;
|
18925
|
+
}
|
18926
|
+
return keep_raw_data_flag;
|
18927
|
+
}
|
18928
|
+
|
18929
|
+
/* Funktion convert_encoding() +���1 */
|
18930
|
+
/* ###########################################################################
|
18931
|
+
* # Diese Funktion konvertiert einen gelesenen LUT-Block in die gew�nschte #
|
18932
|
+
* # Kodierung. Der urspr�nglich allokierte Speicher wird wieder freigegeben.#
|
18933
|
+
* # #
|
18934
|
+
* # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
|
18935
|
+
* ###########################################################################
|
18936
|
+
*/
|
18937
|
+
|
18938
|
+
static int convert_encoding(char **data,UINT4 *len)
|
18939
|
+
{
|
18940
|
+
unsigned char *buffer,*sptr,*dptr,*ptr,*eptr1,*eptr2;
|
18941
|
+
int buflen,offset;
|
18942
|
+
|
18943
|
+
buflen=*len;
|
18944
|
+
switch(encoding){
|
18945
|
+
case 1:
|
18946
|
+
case 51: /* ISO 8859-1 */
|
18947
|
+
current_encoding=(current_encoding/10)*10+1;
|
18948
|
+
break;
|
18949
|
+
|
18950
|
+
case 2: /* UTF-8 */
|
18951
|
+
case 52:
|
18952
|
+
if(!(buffer=malloc(buflen+=8192)))return ERROR_MALLOC;
|
18953
|
+
current_encoding=(current_encoding/10)*10+2;
|
18954
|
+
sptr=UCP *data;
|
18955
|
+
eptr1=sptr+*len;
|
18956
|
+
dptr=buffer;
|
18957
|
+
while(sptr<eptr1){
|
18958
|
+
for(eptr2=buffer+buflen-10;sptr<eptr1 && dptr<eptr2;sptr++)switch(*sptr){
|
18959
|
+
case 0xe4: *dptr++=0xc3; *dptr++=0xa4; break; /* � */
|
18960
|
+
case 0xc4: *dptr++=0xc3; *dptr++=0x84; break; /* � */
|
18961
|
+
case 0xf6: *dptr++=0xc3; *dptr++=0xb6; break; /* � */
|
18962
|
+
case 0xd6: *dptr++=0xc3; *dptr++=0x96; break; /* � */
|
18963
|
+
case 0xfc: *dptr++=0xc3; *dptr++=0xbc; break; /* � */
|
18964
|
+
case 0xdc: *dptr++=0xc3; *dptr++=0x9c; break; /* � */
|
18965
|
+
case 0xdf: *dptr++=0xc3; *dptr++=0x9f; break; /* � */
|
18966
|
+
default: *dptr++=*sptr;
|
18967
|
+
}
|
18968
|
+
if(sptr<eptr1){ /* es wird langsam eng; buffer vergr��ern */
|
18969
|
+
offset=dptr-buffer; /* die Buffer-Adresse verschiebt sich u.U.; dptr mu� korrigiert werden */
|
18970
|
+
if(!(buffer=realloc(buffer,buflen+=4096)))return ERROR_MALLOC;
|
18971
|
+
dptr=buffer+offset;
|
18972
|
+
}
|
18973
|
+
}
|
18974
|
+
buffer=realloc(buffer,buflen=(dptr-buffer)+10);
|
18975
|
+
if(!keep_raw_data_flag)free(*data); /* alte Daten, werden nicht mehr ben�tigt */
|
18976
|
+
*data=SCP buffer;
|
18977
|
+
*len=buflen;
|
18978
|
+
break;
|
18979
|
+
|
18980
|
+
case 3: /* HTML */
|
18981
|
+
case 53:
|
18982
|
+
if(!(buffer=malloc(buflen+=16384)))return ERROR_MALLOC;
|
18983
|
+
current_encoding=(current_encoding/10)*10+3;
|
18984
|
+
sptr=UCP *data;
|
18985
|
+
eptr1=sptr+*len;
|
18986
|
+
dptr=buffer;
|
18987
|
+
while(sptr<eptr1){
|
18988
|
+
for(eptr2=buffer+buflen-10;sptr<eptr1 && dptr<eptr2;sptr++)switch(*sptr){
|
18989
|
+
case 0xe4: for(ptr=UCP "ä"; *ptr;)*dptr++=*ptr++; break; /* � */
|
18990
|
+
case 0xc4: for(ptr=UCP "Ä"; *ptr;)*dptr++=*ptr++; break; /* � */
|
18991
|
+
case 0xf6: for(ptr=UCP "ö"; *ptr;)*dptr++=*ptr++; break; /* � */
|
18992
|
+
case 0xd6: for(ptr=UCP "Ö"; *ptr;)*dptr++=*ptr++; break; /* � */
|
18993
|
+
case 0xfc: for(ptr=UCP "ü"; *ptr;)*dptr++=*ptr++; break; /* � */
|
18994
|
+
case 0xdc: for(ptr=UCP "Ü"; *ptr;)*dptr++=*ptr++; break; /* � */
|
18995
|
+
case 0xdf: for(ptr=UCP "ß";*ptr;)*dptr++=*ptr++; break; /* � */
|
18996
|
+
default: *dptr++=*sptr;
|
18997
|
+
}
|
18998
|
+
if(sptr<eptr1){ /* es wird langsam eng; buffer vergr��ern */
|
18999
|
+
offset=dptr-buffer; /* die Buffer-Adresse verschiebt sich u.U.; dptr mu� korrigiert werden */
|
19000
|
+
if(!(buffer=realloc(buffer,buflen+=8192)))return ERROR_MALLOC;
|
19001
|
+
dptr=buffer+offset;
|
19002
|
+
}
|
19003
|
+
}
|
19004
|
+
if(!keep_raw_data_flag)free(*data); /* alte Daten, werden nicht mehr ben�tigt */
|
19005
|
+
*data=SCP buffer;
|
19006
|
+
*len=buflen;
|
19007
|
+
break;
|
19008
|
+
|
19009
|
+
case 4: /* DOS CP 850 */
|
19010
|
+
case 54:
|
19011
|
+
if(keep_raw_data_flag){ /* Daten kopieren, Kopie bearbeiten */
|
19012
|
+
if(!(buffer=malloc(buflen)))return ERROR_MALLOC;
|
19013
|
+
current_encoding=(current_encoding/10)*10+4;
|
19014
|
+
for(sptr=UCP *data,eptr1=sptr+*len,dptr=buffer;sptr<eptr1;sptr++,dptr++)switch(*sptr){
|
19015
|
+
case 0xe4: *dptr=0x84; break; /* � */
|
19016
|
+
case 0xc4: *dptr=0x8e; break; /* � */
|
19017
|
+
case 0xf6: *dptr=0x94; break; /* � */
|
19018
|
+
case 0xd6: *dptr=0x99; break; /* � */
|
19019
|
+
case 0xfc: *dptr=0x81; break; /* � */
|
19020
|
+
case 0xdc: *dptr=0x9a; break; /* � */
|
19021
|
+
case 0xdf: *dptr=0xe1; break; /* � */
|
19022
|
+
default: *dptr=*sptr;
|
19023
|
+
}
|
19024
|
+
*data=SCP buffer;
|
19025
|
+
*len=buflen;
|
19026
|
+
}
|
19027
|
+
else{ /* !keep_raw_data: die Daten direkt im buffer �ndern */
|
19028
|
+
for(ptr=UCP *data,eptr1=ptr+*len;ptr<eptr1;ptr++)switch(*ptr){
|
19029
|
+
case 0xe4: *ptr=0x84; break; /* � */
|
19030
|
+
case 0xc4: *ptr=0x8e; break; /* � */
|
19031
|
+
case 0xf6: *ptr=0x94; break; /* � */
|
19032
|
+
case 0xd6: *ptr=0x99; break; /* � */
|
19033
|
+
case 0xfc: *ptr=0x81; break; /* � */
|
19034
|
+
case 0xdc: *ptr=0x9a; break; /* � */
|
19035
|
+
case 0xdf: *ptr=0xe1; break; /* � */
|
19036
|
+
}
|
19037
|
+
}
|
19038
|
+
break;
|
19039
|
+
default: /* nicht definierte Kodierung: nichts zu tun */
|
19040
|
+
break;
|
19041
|
+
}
|
19042
|
+
return OK;
|
19043
|
+
}
|
19044
|
+
|
17799
19045
|
DLL_EXPORT const char *pz2str(int pz,int *ret)
|
17800
19046
|
{
|
17801
19047
|
if(ret){
|
@@ -18169,6 +19415,85 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
|
|
18169
19415
|
}
|
18170
19416
|
}
|
18171
19417
|
|
19418
|
+
/* Funktion lut_keine_iban_berechnung() +���1 */
|
19419
|
+
/*
|
19420
|
+
* ############################################################################
|
19421
|
+
* # Die Funktion lut_keine_iban_berechnung() konvertiert die Liste der #
|
19422
|
+
* # Banken, die einer IBAN-Berechnung nicht zugestimmt haben in das interne #
|
19423
|
+
* # Format f�r konto_check. Als Eingabedatei wird die Datei CONFIG.INI des #
|
19424
|
+
* # SEPA Account Converters der Sparkassen benutzt, die Ausgabe wird direkt #
|
19425
|
+
* # als Block in die LUT-Datei geschrieben. Der Block wird automatisch beim #
|
19426
|
+
* # Initialisieren eingelesen und von der Funktion iban_gen() ausgewertet. #
|
19427
|
+
* # #
|
19428
|
+
* # Hier ein Auszug aus der Anleitung des SEPA Account Converters: #
|
19429
|
+
* # #
|
19430
|
+
* # Der SEPA Account Converter ist so eingestellt, dass nur #
|
19431
|
+
* # Kontoverbindungen in IBAN und BIC umgerechnet werden, bei denen das #
|
19432
|
+
* # ausgebende Kreditinstitut der Umrechnung zugestimmt hat. #
|
19433
|
+
* # Kreditinstitute, welche einer Umrechnung nicht zugestimmt haben und #
|
19434
|
+
* # welche zum Teil spezielle, dem SEPA Account Converter nicht bekannte #
|
19435
|
+
* # Umrechnungsmethoden verwenden, sind in der Datei "CONFIG.INI" #
|
19436
|
+
* # hinterlegt. Durch L�schen der Datei "CONFIG.INI" aus dem #
|
19437
|
+
* # Programmverzeichnis haben Sie die M�glichkeit, eine Umrechnung f�r alle #
|
19438
|
+
* # Konten durchzuf�hren. Bitte beachten Sie dabei, dass die so erhaltenen #
|
19439
|
+
* # IBAN und BIC fehlerhaft sein k�nnen und deshalb mit ihren Kunden zu #
|
19440
|
+
* # �berpr�fen sind. #
|
19441
|
+
* ############################################################################
|
19442
|
+
*/
|
19443
|
+
|
19444
|
+
/* Weblinks:
|
19445
|
+
* https://www.sparkasse-rhein-neckar-nord.de/pdf/content/sepa/kurzanleitung.pdf
|
19446
|
+
* https://www.sparkasse-rhein-neckar-nord.de/firmenkunden/internationales_geschaeft/sepa/vorteile/index.php
|
19447
|
+
* https://www.sparkasse-rhein-neckar-nord.de/firmenkunden/internationales_geschaeft/sepa/vorteile/sepa_account_converter.msi
|
19448
|
+
* http://www.sfirm.de/update/prgupd.htm
|
19449
|
+
*/
|
19450
|
+
|
19451
|
+
DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int set)
|
19452
|
+
{
|
19453
|
+
char *ptr,*buffer,line[1024];
|
19454
|
+
int *ibuffer,i,cnt,size,retval;
|
19455
|
+
FILE *in,*lut;
|
19456
|
+
struct stat sbuf;
|
19457
|
+
|
19458
|
+
|
19459
|
+
if(stat(iban_blacklist,&sbuf))return FILE_READ_ERROR;
|
19460
|
+
if(!(in=fopen(iban_blacklist,"r")))return FILE_READ_ERROR;
|
19461
|
+
if(!(lut=fopen(lutfile,"rb+")))return FILE_WRITE_ERROR;
|
19462
|
+
size=sbuf.st_size;
|
19463
|
+
|
19464
|
+
/* grobe Absch�tzung f�r die Gr��e des ben�tigten Arrays: jede BLZ
|
19465
|
+
* ben�tigt 8 Byte. Der Wert size/8 ist etwas zu hoch, aber auf keinen
|
19466
|
+
* Fall zu klein. Da das Array nur zum Sortieren ben�tigt und gleich
|
19467
|
+
* wieder freigegeben wird, ist das egal.
|
19468
|
+
*/
|
19469
|
+
if(!(ibuffer=calloc(size/8,sizeof(int))))return ERROR_MALLOC;
|
19470
|
+
|
19471
|
+
/* die Daten einlesen */
|
19472
|
+
for(cnt=0;!feof(in);){
|
19473
|
+
fgets(line,1024,in);
|
19474
|
+
if(!isdigit(*line))continue; /* Kommentarzeilen etc. */
|
19475
|
+
for(ptr=line,i=0;i++<8&&isdigit(*ptr++););
|
19476
|
+
if(i<8)continue; /* eine BLZ mu� 8 Ziffern enthalten */
|
19477
|
+
if(*ptr=='=' && *(ptr+1)=='0') /* Dateiformat: <BLZ>=0 */
|
19478
|
+
*ptr=0;
|
19479
|
+
else
|
19480
|
+
continue;
|
19481
|
+
ibuffer[cnt++]=atoi(line);
|
19482
|
+
}
|
19483
|
+
qsort(ibuffer,cnt,sizeof(int),cmp_int);
|
19484
|
+
if(!(ptr=buffer=calloc(cnt+10,sizeof(int))))return ERROR_MALLOC;
|
19485
|
+
|
19486
|
+
/* nun den Block in die LUT-Datei schreiben: zuerst die Anzahl, dann die BLZs */
|
19487
|
+
UL2C(cnt,ptr);
|
19488
|
+
for(i=0;i<cnt;i++)UL2C(ibuffer[i],ptr);
|
19489
|
+
retval=write_lut_block_int(lut,LUT2_OWN_IBAN+(set==2?SET_OFFSET:0),ptr-buffer,buffer);
|
19490
|
+
fclose(in);
|
19491
|
+
fclose(lut);
|
19492
|
+
free(buffer);
|
19493
|
+
free(ibuffer);
|
19494
|
+
return retval;
|
19495
|
+
}
|
19496
|
+
|
18172
19497
|
#if DEBUG>0
|
18173
19498
|
/* Funktion kto_check_test_vars() +���1 */
|
18174
19499
|
/* ###########################################################################
|
@@ -18201,11 +19526,14 @@ DLL_EXPORT char *kto_check_test_vars(char *txt,UINT4 i)
|
|
18201
19526
|
/* Leerdefinitionen f�r !INCLUDE_KONTO_CHECK_DE +���1 */
|
18202
19527
|
#include "konto_check.h"
|
18203
19528
|
|
18204
|
-
#define EXCLUDED
|
18205
|
-
#define
|
19529
|
+
#define EXCLUDED {return EXCLUDED_AT_COMPILETIME;}
|
19530
|
+
#define EXCLUDED_V {}
|
19531
|
+
#define EXCLUDED_VP {return NULL;}
|
19532
|
+
#define EXCLUDED_S {return "EXCLUDED_AT_COMPILETIME";}
|
18206
19533
|
#define XI DLL_EXPORT int
|
18207
19534
|
#define XV DLL_EXPORT void
|
18208
19535
|
#define XC DLL_EXPORT char *
|
19536
|
+
#define XCC const DLL_EXPORT char *
|
18209
19537
|
|
18210
19538
|
XI kto_check_blz(char *blz,char *kto)EXCLUDED
|
18211
19539
|
XI kto_check_pz(char *pz,char *kto,char *blz)EXCLUDED
|
@@ -18221,7 +19549,7 @@ XI get_lut_info2_b(char *lutname,int *version,char **prolog_p,char **info_p,char
|
|
18221
19549
|
XI get_lut_info_t(char **info,char *lut_name,KTO_CHK_CTX *ctx)EXCLUDED
|
18222
19550
|
XI get_lut_info2(char *lut_name,int *version_p,char **prolog_p,char **info_p,char **user_info_p)EXCLUDED
|
18223
19551
|
XI get_lut_id(char *lut_name,int set,char *id)EXCLUDED
|
18224
|
-
|
19552
|
+
XCC get_kto_check_version(void)EXCLUDED_S
|
18225
19553
|
XI create_lutfile(char *name, char *prolog, int slots)EXCLUDED
|
18226
19554
|
XI write_lut_block(char *lutname, UINT4 typ,UINT4 len,char *data)EXCLUDED
|
18227
19555
|
XI read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **data)EXCLUDED
|
@@ -18230,9 +19558,10 @@ XI lut_dir_dump(char *filename,char *outputname)EXCLUDED
|
|
18230
19558
|
XI lut_dir_dump_str(char *lutname,char **dptr)EXCLUDED
|
18231
19559
|
XI generate_lut2_p(char *inputname,char *outputname,char *user_info,char *gueltigkeit,
|
18232
19560
|
UINT4 felder,UINT4 filialen,int slots,int lut_version,int set)EXCLUDED
|
18233
|
-
XI generate_lut2(char *inputname,char *outputname,char *user_info,char *gueltigkeit,
|
19561
|
+
XI generate_lut2(char *inputname,char *outputname,const char *user_info,char *gueltigkeit,
|
18234
19562
|
UINT4 *felder,UINT4 slots,UINT4 lut_version,UINT4 set)EXCLUDED
|
18235
19563
|
XI copy_lutfile(char *old_name,char *new_name,int new_slots)EXCLUDED
|
19564
|
+
const XC current_lutfile_name(int *set,int *level,int *retval)EXCLUDED_S;
|
18236
19565
|
XI lut_init(char *lut_name,int required,int set)EXCLUDED
|
18237
19566
|
XI kto_check_init(char *lut_name,int *required,int **status,int set,int incremental)EXCLUDED
|
18238
19567
|
XI kto_check_init_p(char *lut_name,int required,int set,int incremental)EXCLUDED
|
@@ -18245,18 +19574,18 @@ XI lut_filialen(char *b,int *retval)EXCLUDED
|
|
18245
19574
|
XI dump_lutfile(char *outputname,UINT4 *required)EXCLUDED
|
18246
19575
|
XI dump_lutfile_p(char *outputname,UINT4 felder)EXCLUDED
|
18247
19576
|
XI lut_blz(char *b,int zweigstelle)EXCLUDED
|
18248
|
-
|
18249
|
-
|
18250
|
-
|
18251
|
-
|
19577
|
+
XCC lut_name(char *b,int zweigstelle,int *retval)EXCLUDED_S
|
19578
|
+
XCC lut_name_i(int b,int zweigstelle,int *retval)EXCLUDED_S
|
19579
|
+
XCC lut_name_kurz(char *b,int zweigstelle,int *retval)EXCLUDED_S
|
19580
|
+
XCC lut_name_kurz_i(int b,int zweigstelle,int *retval)EXCLUDED_S
|
18252
19581
|
XI lut_plz(char *b,int zweigstelle,int *retval)EXCLUDED
|
18253
19582
|
XI lut_plz_i(int b,int zweigstelle,int *retval)EXCLUDED
|
18254
|
-
|
18255
|
-
|
19583
|
+
XCC lut_ort(char *b,int zweigstelle,int *retval)EXCLUDED_S
|
19584
|
+
XCC lut_ort_i(int b,int zweigstelle,int *retval)EXCLUDED_S
|
18256
19585
|
XI lut_pan(char *b,int zweigstelle,int *retval)EXCLUDED
|
18257
19586
|
XI lut_pan_i(int b,int zweigstelle,int *retval)EXCLUDED
|
18258
|
-
|
18259
|
-
|
19587
|
+
XCC lut_bic(char *b,int zweigstelle,int *retval)EXCLUDED_S
|
19588
|
+
XCC lut_bic_i(int b,int zweigstelle,int *retval)EXCLUDED_S
|
18260
19589
|
XI lut_nr(char *b,int zweigstelle,int *retval)EXCLUDED
|
18261
19590
|
XI lut_nr_i(int b,int zweigstelle,int *retval)EXCLUDED
|
18262
19591
|
XI lut_pz(char *b,int zweigstelle,int *retval)EXCLUDED
|
@@ -18268,6 +19597,9 @@ XI lut_loeschung_i(int b,int zweigstelle,int *retval)EXCLUDED
|
|
18268
19597
|
XI lut_nachfolge_blz(char *b,int zweigstelle,int *retval)EXCLUDED
|
18269
19598
|
XI lut_nachfolge_blz_i(int b,int zweigstelle,int *retval)EXCLUDED
|
18270
19599
|
XI lut_cleanup(void)EXCLUDED
|
19600
|
+
XI kto_check_encoding(int mode)EXCLUDED
|
19601
|
+
XI keep_raw_data(int mode)EXCLUDED
|
19602
|
+
const XC kto_check_encoding_str(int mode)EXCLUDED_S
|
18271
19603
|
const XC kto_check_retval2txt(int retval)EXCLUDED_S
|
18272
19604
|
const XC kto_check_retval2txt_short(int retval)EXCLUDED_S
|
18273
19605
|
const XC kto_check_retval2html(int retval)EXCLUDED_S
|
@@ -18283,24 +19615,26 @@ XI kto_check_blz_dbg(char *blz,char *kto,RETVAL *retvals)EXCLUDED
|
|
18283
19615
|
XI kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals)EXCLUDED
|
18284
19616
|
XC kto_check_test_vars(char *txt,UINT4 i)EXCLUDED_S
|
18285
19617
|
XI set_verbose_debug(int mode)EXCLUDED
|
18286
|
-
|
18287
|
-
XI lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **
|
19618
|
+
XCC pz2str(int pz,int *ret)EXCLUDED_S
|
19619
|
+
XI lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,
|
18288
19620
|
char ***base_name,int **blz_base)EXCLUDED
|
18289
|
-
XI lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int **
|
19621
|
+
XI lut_suche_namen(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,
|
18290
19622
|
char ***base_name,int **blz_base)EXCLUDED
|
18291
|
-
XI lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,int **
|
19623
|
+
XI lut_suche_namen_kurz(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,
|
18292
19624
|
char ***base_name,int **blz_base)EXCLUDED
|
18293
|
-
XI lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **
|
19625
|
+
XI lut_suche_ort(char *such_name,int *anzahl,int **start_idx,int **zweigstelle_base,
|
18294
19626
|
char ***base_name,int **blz_base)EXCLUDED
|
18295
|
-
XI lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int **
|
18296
|
-
XI lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **
|
18297
|
-
XI lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **
|
19627
|
+
XI lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base)EXCLUDED
|
19628
|
+
XI lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base)EXCLUDED
|
19629
|
+
XI lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle_base,int **base_name,int **blz_base)EXCLUDED
|
18298
19630
|
XI kto_check_init_default(char *lut_name,int block_id)EXCLUDED
|
18299
19631
|
XI kto_check_default_keys(char ***keys,int *cnt)EXCLUDED
|
18300
19632
|
XI kto_check_set_default(char *key,char *val)EXCLUDED
|
18301
19633
|
XI kto_check_set_default_bin(char *key,char *val,int size)EXCLUDED
|
18302
19634
|
XI kto_check_get_default(char *key,char **val,int *size)EXCLUDED
|
18303
19635
|
XI kto_check_write_default(char *lutfile,int block_id)EXCLUDED
|
18304
|
-
XV kc_free(char *ptr)
|
18305
|
-
|
19636
|
+
XV kc_free(char *ptr)EXCLUDED_V
|
19637
|
+
DLL_EXPORT void *kc_alloc(int size,int *retval)EXCLUDED_VP
|
19638
|
+
XI set_default_compression(int mode)EXCLUDED
|
19639
|
+
XI lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int set)EXCLUDED
|
18306
19640
|
#endif
|