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 CHANGED
@@ -1,5 +1,5 @@
1
1
  --
2
2
  :major: 0
3
3
  :minor: 0
4
- :patch: 6
4
+ :patch: 7
5
5
 
@@ -48,9 +48,9 @@
48
48
 
49
49
  /* Definitionen und Includes */
50
50
  #ifndef VERSION
51
- #define VERSION "3.6"
51
+ #define VERSION "4.0"
52
52
  #endif
53
- #define VERSION_DATE "2011-04-13"
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). Immer dabei sind Infoblock, BLZ und Prfziffer; sie
329
- * werden daher nicht aufgefhrt.
385
+ * Beispielssets). Im Kommentar ist angegeben, wieviele Slots (fr die
386
+ * Daten + Indizes) fr 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],lc[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 suche_str(char *such_name,int *anzahl,int **start_idx,int **zweigstelle,int **blz_base,
547
- char ***base_name,int **base_sort,int(*cmp)(const void *, const void *));
548
- static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstelle,int **blz_base,
549
- int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int cnt);
550
- static int suche_int2(int a1,int a2,int *anzahl,int **start_idx,int **zweigstelle,int **blz_base,
551
- int **base_name,int **base_sort,int(*cmp)(const void *, const void *));
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 inline int stri_cmp(char *a,char *b);
554
- static inline int strni_cmp(char *ap,char *bp);
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 sort_int() +���1 */
745
+ /* Funktion cmp_int() +���1 */
681
746
  /* ###########################################################################
682
- * # Diese Funktion dient zum Sortieren der Eintrge beim Kopieren einer #
683
- * # LUT-Datei. #
747
+ * # Diese Funktion dient als Vergleichsfunktion fr 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 sort_int(const void *ap,const void *bp)
754
+ static int cmp_int(const void *a,const void *b)
690
755
  {
691
- return *((int *)ap)- *((int *)bp);
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,FILE *lut,UINT4 set)
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 out_buffer+4.
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=out_buffer+4;i<bank_cnt;i++){
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=out_buffer;
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-out_buffer,out_buffer));
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=out_buffer;i<bank_cnt;i++){
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-out_buffer,out_buffer));
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || (hs=qs_hauptstelle[qs_sortidx[i]])=='1'){
1510
- zptr=qs_zeilen[qs_sortidx[i]];
1511
- hs=qs_hauptstelle[qs_sortidx[i]];
1512
- if(hs=='1' && auch_filialen){
1513
- *dptr++=1; /* Markierung f�r Hauptstelle, kann im Text nicht vorkommen */
1514
- name_hauptstelle=dptr;
1515
- }
1516
- else
1517
- name_start=dptr;
1518
- for(ptr=zptr+9;ptr<zptr+67;)*dptr++=*ptr++;
1519
- if(*(dptr-1)==' '){
1520
- for(dptr--;*dptr==' ';)dptr--;
1521
- dptr++; /* das letzte Byte war kein Blank mehr */
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || (hs=qs_hauptstelle[qs_sortidx[i]])=='1'){
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
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
- j=Z(b5,67)+Z(b4,68)+Z(b3,69)+Z(b2,70)+Z(b1,71);
1572
- UM2C(j,dptr);
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || (hs=qs_hauptstelle[qs_sortidx[i]])=='1'){
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
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
- j=0;
1767
+ k=0;
1611
1768
  else
1612
- j=Z(b5,134)+Z(b4,135)+Z(b3,136)+Z(b2,137)+Z(b1,138);
1613
- UM2C(j,dptr);
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-out_buffer,out_buffer));
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
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-out_buffer,out_buffer));
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=out_buffer;i<bank_cnt;i++){
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-out_buffer,out_buffer));
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
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-out_buffer,out_buffer));
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
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-out_buffer,out_buffer));
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
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-out_buffer,out_buffer));
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=out_buffer;i<bank_cnt;i++)if(auch_filialen || qs_hauptstelle[qs_sortidx[i]]=='1'){
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-out_buffer,out_buffer));
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 30 Slots angelegt. Die Slots brauchen nicht viel
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=30; break; /* 3 Slots/Satz */
1737
- case 1: felder1=(UINT4 *)lut_set_1; if(!slots)slots=30; break; /* 4 Slots/Satz */
1738
- case 2: felder1=(UINT4 *)lut_set_2; if(!slots)slots=30; break; /* 5 Slots/Satz */
1739
- case 3: felder1=(UINT4 *)lut_set_3; if(!slots)slots=30; break; /* 6 Slots/Satz */
1740
- case 4: felder1=(UINT4 *)lut_set_4; if(!slots)slots=30; break; /* 7 Slots/Satz */
1741
- case 5: felder1=(UINT4 *)lut_set_5; if(!slots)slots=30; break; /* 7 Slots/Satz */
1742
- case 6: felder1=(UINT4 *)lut_set_6; if(!slots)slots=30; break; /* 8 Slots/Satz */
1743
- case 7: felder1=(UINT4 *)lut_set_7; if(!slots)slots=30; break; /* 9 Slots/Satz */
1744
- case 8: felder1=(UINT4 *)lut_set_8; if(!slots)slots=35; break; /* 10 Slots/Satz */
1745
- case 9: felder1=(UINT4 *)lut_set_9; if(!slots)slots=40; break; /* 12 Slots/Satz */
1746
- default: felder1=(UINT4 *)lut_set_9; if(!slots)slots=40; break; /* 12 Slots/Satz */
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 67360Lingenfeld Testbank 52 Lingenfeld 12345TESTDEX987652130000U000000000\n"
1812
- "160520721Testbank Verfahren 53 67360Lingenfeld Testbank 53 Lingenfeld 12345TESTDEX987653130000U000000000\n"
1813
- "800537721Testbank Verfahren B6 67360Lingenfeld Testbank B6 Lingenfeld 12345TESTDEX9876B6130000U000000000\n"
1814
- "800537821Testbank Verfahren B6 67360Lingenfeld Testbank B6 Lingenfeld 12345TESTDEX9876B6130000U000000000\n";
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,"G�ltigkeit der Daten: %08u-%08u (%s Datensatz)\nEnthaltene Felder:",
2011
- g1,g2,set<2?"prim�rer":"sekund�rer");
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)\ndieser Datensatz enth�lt %s\n"
2035
- "Kompression: %s\n"
2036
- "Datei-ID (zuf�llig, f�r inkrementelle Initialisierung):\n"
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 L�nge kompr. Verh. Adler32 Test\n");
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),sort_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
- for(iptr=required,rptr=xrequired+2;*iptr;iptr++)
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=lut2_block_len[typ]=lut2_block_len[typ1]=0;
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
- for(j=0;j<i;j++)
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]="nicht definiert";
4576
- lut_block_name2[i]="nicht def.";
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
- * # Berechnung nach der Methode B6 #
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 beinhalten, sind nach der Methode 20 zu pr�fen. #
12529
- * # Alle anderen Kontonummern sind nach der Variante 2 zu pr�fen. #
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 7. Juni 2010) #
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 9.3.2009; �nderung zum 6.6.2011 */
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 7. Juni 2010) #
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 2, 7 oder 8 beinhalten sind falsch. #
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
- if(*kto=='2' || *kto=='7' || *kto=='8')return INVALID_KTO;
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++==0x73&&*blz++==0x75&&*blz++==0x6d&&*blz==0x6d&&*ee)return EE;
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,retvals);
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&uuml;r die Default-Kompression ist ung&uuml;ltig";
15781
16108
  case OK_UNTERKONTO_ATTACHED: return "wahrscheinlich OK; es wurde allerdings ein (weggelassenes) Unterkonto angef&uuml;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) die #
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 f�r LUT2",NULL,lut_set,20,3,0);
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
- /* erstmal das Konto testen */
16775
- if(*blz=='+') /* kein Test */
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
- #if DEBUG
16778
- else if((ret=kto_check_blz_x(blz,kto,&uk_cnt,&retvals))<=0){ /* Konto fehlerhaft */
16779
- #else
16780
- else if((ret=kto_check_blz_x(blz,kto,&uk_cnt))<=0){ /* Konto fehlerhaft */
16781
- #endif
16782
- if(retval)*retval=ret;
16783
- return NULL;
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
- for(ptr=zweck;*ptr;ptr++); /* ptr auf Ende des Verwendungszwecks setzen */
17009
- for(dptr=buffer+20;ptr>=zweck;*dptr--=toupper(*ptr--))if(*ptr && !isalnum(*ptr))return IPI_INVALID_CHARACTER;
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 stri_cmp() +���2 */
17117
- /* diese Funktion macht dasselbe wie strcasecmp(), ist allerdings portabel:
17118
- * strcmp ohne Gro�/Kleinschreibung, dazu noch Umlaute nach ISO-8859-1
17119
- * (diese werden bei den entsprechenden Grundbuchstaben einsortiert).
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 inline int stri_cmp(char *a,char *b)
17483
+ static int get_sortc(char **a,int enc)
17122
17484
  {
17123
- while(*a && lc[UI *a]==lc[UI *b])a++,b++;
17124
- return lc[UI *a]-lc[UI *b];
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
+ * &szlig;
17762
+ * &quot;
17763
+ * &amp;
17764
+ * &lt;
17765
+ * &gt;
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() +���2 */
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 Bankleitzahlen benutzt.
17876
+ * bei der Suche nach Orten oder Banknamen benutzt.
17132
17877
  */
17133
- static inline int strni_cmp(char *a,char *b){
17134
- while(*a && lc[UI *a]==lc[UI *b])a++,b++;
17135
- if(*a)
17136
- return lc[UI *a]-lc[UI *b];
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() +���2 */
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() +���2 */
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
- for(l=0,r=cnt-1,x=(l+r)/2;(y=strni_cmp(a,base[sort_a[x]])) && y && l<r;){
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 && !strni_cmp(a,base[sort_a[l]]);l--);
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 && !strni_cmp(a,base[sort_a[r]]);r++);
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() +���2 */
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() +���2 */
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() +���2 */
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() +���2 */
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() +���2 */
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() +���2 */
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() +���2 */
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 suche_int1() +���2 */
17288
- static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstelle,int **blz_base,
17289
- int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int cnt)
17290
- {
17291
- int i,unten,retval,*b_sort;
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,k,n,cnt,unten,retval,*b_sort;
18077
+ int cnt,i,j,n,k;
17316
18078
 
17317
- if(!a2)a2=a1;
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
- if(!(b_sort=calloc(cnt+10,sizeof(int)))){
17349
- if(blz_f!=blz)
17350
- FREE(blz_f);
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 ERROR_MALLOC;
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
- RETURN(retval);
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 suche_str() +���2 */
17373
- static int suche_str(char *such_name,int *anzahl,int **start_idx,int **zweigstelle,int **blz_base,
17374
- char ***base_name,int **base_sort,int(*cmp)(const void *, const void *))
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
- int i,j,k,n,cnt,unten,retval,*b_sort;
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(startidx[lut2_cnt_hs-1]==lut2_cnt_hs-1){ /* keine Filialen in der Datei enthalten */
17379
- cnt=lut2_cnt_hs;
17380
- blz_f=blz; /* die einfache BLZ-Tabelle reicht aus */
17381
- }
17382
- else
17383
- cnt=lut2_cnt;
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
- return ERROR_MALLOC;
18191
+ FREE(zweigstelle_f);
18192
+ return retval;
17389
18193
  }
17390
- for(i=j=0;i<lut2_cnt_hs;i++)if((n=filialen[i])>1){
17391
- for(k=0;k<n;k++){
17392
- zweigstelle_f[j]=k;
17393
- blz_f[j++]=blz[i];
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
- zweigstelle_f[j]=0;
17398
- blz_f[j++]=blz[i];
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(zweigstelle)*zweigstelle=zweigstelle_f;
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
- if(!(b_sort=calloc(cnt+10,sizeof(int)))){
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 ERROR_MALLOC;
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 **zweigstelle,
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,zweigstelle,blz_base,&bic,&sort_bic,qcmp_bic);
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 **zweigstelle,
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,zweigstelle,blz_base,&name,&sort_name,qcmp_name);
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 **zweigstelle,
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,zweigstelle,blz_base,&name_kurz,&sort_name_kurz,qcmp_name_kurz);
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 **zweigstelle,
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,zweigstelle,blz_base,&ort,&sort_ort,qcmp_ort);
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 **zweigstelle,int **base_name,int **blz_base)
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(zweigstelle){
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
- *zweigstelle=zweigstelle_f1;
18359
+ *zweigstelle_base=zweigstelle_f1;
17489
18360
  }
17490
- return suche_int1(such1,such2,anzahl,start_idx,zweigstelle,blz_base,&blz,&sort_blz,qcmp_blz,cnt);
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 **zweigstelle,int **base_name,int **blz_base)
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(zweigstelle){
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
- *zweigstelle=zweigstelle_f1;
18379
+ *zweigstelle_base=zweigstelle_f1;
17509
18380
  }
17510
- return suche_int1(such1,such2,anzahl,start_idx,zweigstelle,blz_base,&pz_methoden,&sort_pz_methoden,qcmp_pz_methoden,cnt);
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 **zweigstelle,int **base_name,int **blz_base)
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,zweigstelle,blz_base,&plz,&sort_plz,qcmp_plz);
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 "&auml;"; *ptr;)*dptr++=*ptr++; break; /* � */
18990
+ case 0xc4: for(ptr=UCP "&Auml;"; *ptr;)*dptr++=*ptr++; break; /* � */
18991
+ case 0xf6: for(ptr=UCP "&ouml;"; *ptr;)*dptr++=*ptr++; break; /* � */
18992
+ case 0xd6: for(ptr=UCP "&Ouml;"; *ptr;)*dptr++=*ptr++; break; /* � */
18993
+ case 0xfc: for(ptr=UCP "&uuml;"; *ptr;)*dptr++=*ptr++; break; /* � */
18994
+ case 0xdc: for(ptr=UCP "&Uuml;"; *ptr;)*dptr++=*ptr++; break; /* � */
18995
+ case 0xdf: for(ptr=UCP "&szlig;";*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 {return EXCLUDED_AT_COMPILETIME;}
18205
- #define EXCLUDED_S {return "EXCLUDED_AT_COMPILETIME";}
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
- XC get_kto_check_version(void)EXCLUDED_S
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
- XC lut_name(char *b,int zweigstelle,int *retval)EXCLUDED_S
18249
- XC lut_name_i(int b,int zweigstelle,int *retval)EXCLUDED_S
18250
- XC lut_name_kurz(char *b,int zweigstelle,int *retval)EXCLUDED_S
18251
- XC lut_name_kurz_i(int b,int zweigstelle,int *retval)EXCLUDED_S
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
- XC lut_ort(char *b,int zweigstelle,int *retval)EXCLUDED_S
18255
- XC lut_ort_i(int b,int zweigstelle,int *retval)EXCLUDED_S
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
- XC lut_bic(char *b,int zweigstelle,int *retval)EXCLUDED_S
18259
- XC lut_bic_i(int b,int zweigstelle,int *retval)EXCLUDED_S
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
- XC const pz2str(int pz,int *ret)EXCLUDED_S
18287
- XI lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstelle,
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 **zweigstelle,
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 **zweigstelle,
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 **zweigstelle,
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 **zweigstelle,int **base_name,int **blz_base)EXCLUDED
18296
- XI lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle,int **base_name,int **blz_base)EXCLUDED
18297
- XI lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstelle,int **base_name,int **blz_base)EXCLUDED
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)EXCLUDED
18305
- XV set_default_compression(int mode)EXCLUDED
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