a99  V32.6
allegro Windows Hauptprogramm
 Alle Klassen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
utility.cpp
gehe zur Dokumentation dieser Datei
1 // UTILITY.CPP : Hilfsfunktionen (c) UB Braunschweig 1995
2 // 1995-08-19
3 // Copyright 2011 Universitätsbibliothek Braunschweig, more see bottom
4 
5 #ifdef WIN32
6 #include <windows.h>
7 #endif
8 
9 #include "allegro.hpp"
10 
11 // 1. utilities, for strings and such
12 // names begin with Ut
13 
14 // 2. Background management (Hintergrundspeicher)
15 // UtFIns(), UtFInsSf(), UtFinst(), UtFdel()
16 // UtFind() for external use, , UtFindX() for internal use
17 
18 // 3. Phrase managament (Phrasenspeicher; Einricht. in KONFIG.CPP)
19 // UtPinst(), UtPdel(), UtPfind() for external use
20 
21 int pos; // glob f. this module
22 
23 // $$980722 : Testfunktion
24 int ixspace(char c) // characters <0 and > 127 problematic!!
25 {
26  if (c>0 && c<128 && isspace((int)c)) return 1;
27  else return 0;
28 }
29 
30 #ifdef UNIX
31 void Ulowtype(CHAR *a) // turn file type into small letters UNIX!
32 {
33  int i=3;
34  CHAR *b;
35  b=a+strlen(a)-3;
36  while (i)
37  {
38  *b=tolower(*b);
39  --i;
40  ++b;
41  }
42  return;
43 }
44 /*
45 int isSpace(CHAR c)
46 {
47  if (c<128 && isspace((int)c)) return 1;
48  else return 0;
49 }
50 
51 int isSpace(char c)
52 {
53  if ((CHAR)c<(CHAR )128 && isspace((int)c)) return 1;
54  else return 0;
55 }
56 */
57 // $$980206 ve: neue Fkt.: File-Locking unter UNIX setzen/freigeben
58 int sperre_einaus(int fd, int kdo, int sperr_typ,
59  off_t offset, int wie, off_t laenge)
60 {
61  struct flock sperre;
62 
63  sperre.l_type = sperr_typ; // F_RDLCK, F_WRLCK oder F_UNLCK
64  sperre.l_start = offset; // Byte-Offset (abhaengig von wie)
65  sperre.l_whence = wie; // SEEK_SET, SEEK_CUR oder SEEK_END
66  sperre.l_len = laenge; // Anzahl von Bytes; 0 bedeutet bis EOF
67 
68  return( fcntl(fd, kdo, &sperre) );
69 }
70 
71 #else // Windows
72 #define isSpace(x) isspace(x)
73 #endif
74 
75 void UtLower(CHAR *a) // turn all chars into lower
76 {
77  CHAR *b;
78  b=a;
79  while (*b)
80  {
81  *b=tolower(*b);
82  ++b;
83  }
84  return;
85 }
86 
87 void UtUpper(CHAR *a) // turn all chars into upper
88 {
89  CHAR *b;
90  b=a;
91  while (*b)
92  {
93  *b=toupper(*b);
94  ++b;
95  }
96  return;
97 }
98 
99 
100 void UtRemsp(CHAR *a) // remove whitespace at end of a
101 {
102  CHAR *b;
103  if (!*a) return;
104  b=(CHAR *)a+strlen(a)-1;
105  while (b>=a)
106  {
107  if (isSpace(*b)) *b--=0;
108  else break;
109  }
110  return;
111 }
112 
113 // $$980703 ve: Neue Hilfsfunktion
114 void UtRemspB(CHAR *string,CHAR rem) // remove char "rem" at beginning of string
115 {
116  int i=0,len=strlen(string);
117  while (i<len && string[i]==rem)i++;
118  if (i>0) memmove(string,string+i,len+1-i);
119  return;
120 }
121 
122 // Kommentar aus Param.Zeile beseitigen: Bei 2 Spatien abschneiden
123 void UtRemCom(char *a) // remove comments preceded by 2 spaces, except quoted text.
124 // both ' and " are quotes!
125 {
126  int i=0;
127  UtRemsp((CHAR *)a);
128  while (a[i]) if (a[i++]==QT) while (a[i] && a[i++]!=QT);
129  else if (a[i-1]==39) while (a[i] && a[i++]!=39); // single Quote
130  else if (ixspace(a[i-1]) && ixspace(a[i]) && a[i-2]!=',')
131  {
132  a[i-1]=NL;
133  break;
134  }
135  return;
136 }
137 
138 // Ende einer Zeichenfolge finden und mit 0 markieren
139 void UtEndSf(char *u, char e) // u=Zeichenfolge, e= Endzeichen, z.B. Code 31
140 {
141  char *a; a=u;
142  while(*a && *++a!=e);
143  *a=0;
144 }
145 
146 // lValue in die Grenzen zwischen lMin und lMax zwingen, RECNR = long
147 void UtRange(RECNR lMin,RECNR & lValue,RECNR lMax)
148 {
149  if (lValue < lMin) lValue=lMin;
150  else if (lValue > lMax) lValue=lMax;
151  return;
152 }
153 
154 // ***********************************************************
155 // BACKGROUND MANAGEMENT : Hintergrundspeicher
156 // Arrays fa[] (Adressen), fi[] interne Nummern GLOBAL!
157 
158 bool UtFIns(CHAR *w, int tgl) // tgl default = 2
159 {
160  return UtFinst(w,2049+w[2]-97,tgl); // #uab: 2049 als interner Wert weil a=97
161 }
162 
163 bool UtFinst(CHAR *wc, int f, int tgl) // insert field at wc into fa[], f into fi[]
164 // f is wc's internal number; tgl=2,3,4 (t-Wert aus CFG) wg. Position d. Textes hinter #uxy
165 {
166  int i, j;
167  unsigned int k, cnt, cnt1;
168  char F;
169  if (*wc==RS) wc+=2;
170  if (wc[1]=='u') k=3;
171  else k=tgl+1;
172 
173 // Platzmangel wird abgefangen
174  if (fend+1+strlen(wc)-fr>fspace || fri>=f_dim-3) return false; // we lack space
175 
176  else
177  {
178  i=fri-1;
179  while (i>-1 && f<fi[i]) --i;
180  j=2; // 2 : not found, insert it
181  if (i>-1 && f==fi[i]) // found: we already have text under this internal number
182  {
183  if (wc[k]=='~') wc[k]=254;
184  while (f==fi[i] && wc[k]<fa[i][k]) --i;
185  if (f==fi[i])
186  {
187  if (wc[1]!='u') // nicht fuer #u...
188  { // Mehrfachfelder Hintergr.Sp.
189  if ((F=wc[k]+1)==' '+1) F='a'; // care for the 3rd char
190  if (i<fri-1 && f==fi[i+1])
191  {
192  if (i<fri-2 && f==fi[i+2]) UtFdel(i+2);
193  fa[i+1][k]=F+1;
194  }
195  if (wc[k]==fa[i][k]) fa[i][k]=F; //$$990630 NEU if(..)
196  else ++i;
197  }
198  else // #u-Felder
199  {
200  if (wc[k]!=254) if (wc[k]==fa[i][k]) UtFdel(i); // don't stack #u-variables
201  else ++i;
202  else
203  {
204  wc[k]=fa[i][k]+1;
205  ++i;
206  if (wc[k]>122 && wc[k]<128) wc[k]=128; // don't use '{|}~'
207  }
208 // if(strlen(wc)<=skt) return; // there's no text in it
209  }
210  }
211  else // 2003-11-25
212  ++i;
213  }
214  else ++i;
215  if (wc[k]=='~') if (wc[1]=='u') wc[k]='0';
216  else wc[k]=' '; // remove ~
217  if (i==-1) i=j=0; // field not found
218  if (j==2 && i==fri-1) if (f==fi[i] && fa[i][k]==wc[k]) j=3;
219  switch (j)
220  {
221  case 3:
222  if (fri) fri--;
223  fend=fa[fri]; // delete last field
224  // flothru
225  case 0: // append field at end
226  fa[fri]=fend;
227  fend+=strlen(wc)+1;
228  fi[fri]=f;
229  strcpy(fa[fri],wc);
230  ++fri;
231  break;
232  case 2: // insert
233  cnt=1+strlen(wc);
234  cnt1=fend-fa[i];
235  memmove(fa[i]+cnt,fa[i],cnt1);
236  j=fri;
237  while (j>i)
238  {
239  fa[j]=fa[j-1]+cnt;
240  fi[j]=fi[j-1];
241  --j;
242  }
243  strcpy(fa[i],wc);
244  fi[i]=f;
245  fend+=cnt;
246  ++fri;
247  break;
248  }
249  fa[fri]=fend;
250  fi[fri]=0; // Endemarkierung
251  }
252 
253  return true;
254 }
255 
256 // fA = Datenfeld, w= $aText
257 
258 bool UtFInsSub(CHAR *fA,CHAR *w)
259 {
260  CHAR *fN; // feld Neu
261  fN= new CHAR[strlen(w)+strlen(fA)+10]; // Hilfsfeld
262  int l=0;
263  strcpy(fN,fA);
264  if(w[2]=='+')
265  { sprintf((char *)fN+strlen(fN),"%c%c%s",w[0],w[1],w+3);
266  UtFIns((CHAR *)fN);
267  }
268  else while(1) // Unterfeld in fA suchen
269  {
270  int n=0;
271  while(fN[n])
272  {
273  if(fN[n]==31 && fN[n+1]==w[1]) break;
274  ++n;
275  }
276  if(fN[n]) // Das Unterfeld ist gefunden
277  {
278  int m=n+2;
279  while(fN[m] && fN[m]!=31) ++m; // dann m-n = laenge des Unterfelds
280  if(strlen(w)>3) strcpy(fN+n,fN+m); // altes subf rausnehmen
281  sprintf((char *)fN+strlen(fN),"%c%c%s",31,w[1],w+7);
282  }
283  // nicht gef., dann einfuegen falls nichtleer
284  else if(w[2] && strlen(w)>3)
285  {
286  sprintf((char *)fN,"%s%c%c%s",fA,31,w[1],w+7);
287  }
288  UtFIns((CHAR *)fN); // und einfuegen, d.h. vorh. ersetzen
289  break;
290  }
291  delete fN;
292  return 1;
293 }
294 
295 
296 // Unterfeld in #uxx einfuegen, ersetzen wenn schon vorhanden
297 bool UtFInsSf(CHAR *w, int tg) // w = "$a-#uxyTEXT oder $a+#uxyTEXT
298 {
299  char tag[5];
300  strncpy(tag,w+3,4); tag[4]=0; // tag = "#uxy"
301  CHAR *fA; // feld Alt
302  fA=UtFind(tag);
303 
304  if(!fA) // feld in #u.. nicht gefunden
305  {
306  sprintf((char *)w,"%s %c%c%s",tag,31,w[1],w+7);
307  // now: w = #uxy $aTEXT
308  UtFIns((CHAR *)w);
309  return 1;
310  }
311  if(w[2]=='+') strcpy(w+3,w+7); // now w = $aTEXT or $a+TEXT
312  else strcpy(w+2,w+7); // now w = $aTEXT
313  UtFInsSub(fA,w);
314  return 1;
315 }
316 
317 
318 CHAR *UtFind(char *kat) // find kat="#uxy" in background store
319 { // return: String Adresse
320  int i=fri-1;
321  while (i>=0)
322  if (strncmp((char *)fa[i],kat,4)) --i;
323  else break;
324  if (i>=0) return fa[i];
325  else return (CHAR*)NULL;
326 }
327 
328 int UtFindI(CHAR *kat, int lg) // find kat="#uxy" in background store, ret index
329  // lg = Laenge f.d. Vergleich, meist 4
330  { // return: Index i des gefundenen Felds in fa[], d.h. fa[i] ist die Adresse
331  int i=0;
332  while(i<fri)
333  if(strncmp((char *)fa[i],kat,lg)) ++i; else break;
334  if(i<fri) return i;
335  else return -1;
336  }
337 
338 int UtFindX(int a, CHAR b, int tgl) // a=interne Nr. lt CFG, b=Mehrfachcode
339 { // return the number i of fa[i]
340  int i=fri;
341  int k=tgl+1;
342  if (a>1950) k=3; // #uxy
343  while (i && fi[--i]>a);
344  while (i>=0 && fi[i]==a && b!=fa[i][k]) --i;
345  if (fi[i]!=a) return EOF;
346  if (b==fa[i][k] || b=='.') return i; // #uxb or #ux.
347  return EOF;
348 }
349 
350 
351 void UtFdel(int i) // delete field i from background space
352  // z.B. #uwa loeschen: m=UtFindI("#uwa",4); UtFdel(m);
353 {
354  int j, cnt;
355  if (i<fri-1)
356  {
357  cnt=fend-fa[i+1];
358  if (cnt>0) memmove(fa[i],fa[i+1],cnt);
359  j=i+1;
360  fi[i]=fi[j];
361  cnt=fa[j]-fa[i];
362 
363  while (j<fri)
364  {
365  fa[j]=fa[j+1]-cnt;
366  fi[j]=fi[j+1];
367  ++j;
368  }
369  }
370  if (fri) fri--;
371  fi[fri]=0;
372  fend=fa[fri];
373  return;
374 }
375 
376 void UtFDel(char c) // $$981123 NEU: loesche alle #ucx, wenn c=~: saemtliche #uxy
377  // also z.B. UtFDel('a'): Loesche alle #uax
378 {
379  int i=0;
380  while (i<fri) if (fa[i][1]!='u' || (fa[i][2]!=c && c!='~')) ++i;
381  else break;
382  while (i<fri && fa[i][1]=='u' && (fa[i][2]==c || c=='~')) UtFdel(i);
383  return;
384 }
385 
386 
387 
388 // -------------------------------------------------------------------------
389 // PHRASE SPACE MANAGEMENT : Phrasenspeicher [global!]
390 
391 /* phrase space usage:
392  k=
393  0 + j editor's phrases (manual)
394  1000 + Ps*400 + j fix j (texels)
395  3000 + j search strings as entered
396  6000 + j standardized srch strings
397  10000 + Ps*300 + j ersatz p values (Ps=0,1,2,3) 0=IndexParam, 2=DisplParam, 3=ExpParam
398  20000 + Ps*300 + j ersatz q
399  30000 + Ps*500 + j global replace strings for param set Ps
400  40000 + Adn*100 +j global repl for database Adn
401 */
402 
403 int UtPinst(CHAR *w,int k) // insert text at w as phrase k into phrase array
404  // z.B. UtPinst("abc",999);
405 {
406  int i, j, f, cnt, cnt1;
407 
408  if ((pend+2+strlen(w))-phr>pspace)
409  {
410  sprintf(Aerror,uif[48]); // " Kein Platz mehr fuer Phrasen!"
411  return -1;
412  }
413  else
414  {
415  i=0;
416  f=k;
417  while (f>pi[i] && pi[i]>0) ++i;
418  if (f==pi[i]) j=1;
419  else j=2; // 1 found / 2 not foun
420  if (i==phi) j=0; // field not found
421  if (j==1 && i==phi-1) j=3;
422  switch (j)
423  {
424  case 3:
425  phi--;
426  pend=pa[phi]; // delete last field
427  // flothru
428  case 0: // append field at end
429  cnt=strlen(w)+1;
430  if (cnt>1)
431  {
432  pa[phi]=pend;
433  pend+=cnt;
434  pi[phi]=f;
435  memmove(pa[phi],w,cnt);
436  ++phi;
437  }
438  break;
439  case 1: // delete + insert
440  UtPdel(i);
441  // flothru
442  case 2: // inser
443  cnt=strlen(w)+1;
444  if (cnt>1)
445  {
446  CHAR *dest;
447  dest=pa[i]+cnt;
448  cnt1=cnt;
449  cnt=pend-pa[i]+1;
450  memmove(dest,pa[i],cnt);
451  cnt=cnt1;
452  j=phi;
453  while (j>i)
454  {
455  pa[j]=pa[j-1]+cnt;
456  pi[j]=pi[j-1];
457  j--;
458  }
459  strcpy(pa[i],w);
460  pi[i]=f;
461  pend+=cnt;
462  ++phi;
463  }
464  break;
465  }
466  pa[phi]=pend;
467  pi[phi]=0;
468  *pend=0; // redundant?
469  }
470  return(i); // internal number of phrase
471 }
472 
473 int UtPfind(int nr) // Phrase nr finden, z.B. p=UtPfind(999);
474 // return number p, pa[p] is then the address
475 {
476  int p=0;
477  while (p<phi && pi[p]!=nr) ++p;
478  if (pi[p]==nr) return p;
479  else return EOF;
480 }
481 
482 void UtPdel(int i) // delete phrase i, z.B. UtPdel(999);
483 {
484  int j; unsigned int cnt;
485  cnt=pend-pa[i+1];
486  if (cnt>0) memmove(pa[i],pa[i+1],cnt);
487  j=i+1;
488  pi[i]=pi[j];
489  cnt=pa[j]-pa[i];
490  pend-=cnt;
491  while (j<phi)
492  {
493  pa[j]=pa[j+1]-cnt;
494  pi[j]=pi[j+1];
495  ++j;
496  }
497  phi--;
498  pi[phi]=0;
499  return;
500 }
501 
502 // ------------------------------------------------------------------------------
503 int geti(int i) // get int value from wx at pos i, set pos after int
504 // ret: int value ; pos=0 after NL
505 // exceptions: >A --> A+128 / :i and ;i -> 10i / 11i
506 {
507  int j;
508  CHAR z[9];
509  j=i;
510  if (Awx[i]) if (isspace(Awx[i])) ++i;
511  if (!Awx[i])
512  {
513  pos=0;
514  return(0);
515  }
516  if (Awx[i]=='>') // subroutine call instead of a fix
517  {
518  pos=i+2;
519  return(Awx[i+1]+128);
520  }
521  if (!isdigit(Awx[i]))
522  { // $$950602: to allow |:i and |;i
523  if (Awx[i]==':' || Awx[i]==';')
524  {
525  pos=i+2;
526  return((Awx[i]-'0')*10+Awx[i+1]-'0');
527  }
528  pos=i+1;
529  return Awx[i];
530  } // no digit: value of char
531  j=0;
532  while (isdigit(Awx[i])) z[j++]=Awx[i++];
533  z[j]=NL;
534  pos=i;
535  return(atoi(z));
536 }
537 
538 
539 // Export-Steuerzeichenkette einlesen und umwandeln in interne Form
540 void getst(int i, CHAR *adr) // get control string from wx at pos i to adr
541 {
542  int j=0;
543  int m;
544  unsigned char cx;
545  while (pos!=0 && Awx[i]!=NL)
546  {
547  switch (Awx[i])
548  {
549  case QT: // quoted string
550  ++i;
551  while ((cx=adr[j++]=Awx[i++])!=QT && cx!=NL) ;
552  if (cx==NL) pos=0;
553  if (cx==QT) adr[--j]=NL;
554  break;
555 
556  case ' ': // two spaces=terminator
557  if (Awx[++i]==' ') Awx[i]=NL; // end of ctrl string
558  break;
559 
560  default: // numbers as ctrl-chars
561  m=geti(i); // special coding for NULL:
562  adr[j++]=m;
563  i=pos; // pos was set to position after number!
564  break;
565  } // end switch
566  } // end while
567  adr[j]=NL;
568  return;
569 }
570 
571 // **********************************
572 // $$010122 UIF-Datei einlesen
573 int uifRead(char n, char *dir) // read uif texts
574 {
575  static char *uifp;
576  int i,k,y;
577  char ui[32]="uif0ger";
578  FILE *uifile;
579  k=y=0;
580  if (*uift==NL) uifp=uift; // initialize
581  strcpy(ui+4,Alanguage);
582  ui[3]=n;
583 
584 #ifdef UNIX
585 UIFOPEN:
586 #endif
587  if (!(uifile=SyOpen(ui,"rt",dir))) // 1st try with language
588  {
589  strcpy(ui,"uif0");
590  ui[3]=n;
591  if (!(uifile=SyOpen(ui,"rt",dir))) // 2nd try without language
592  {
593 // Bei UNIX noch ein Versuch mit kleingeschriebenem Dateinamen
594 #ifdef UNIX
595  if (isupper(ui[0]))
596  {
597  UtLower((CHAR *)ui);
598  goto UIFOPEN;
599  }
600 #endif
601  sprintf(Aerror,"no user interface: file %s%s missing%c",ui,Alanguage,0);
602  return 0;
603  }
604  }
605  while (fgets((char *)Awx,255,uifile)!=NULL && *Awx!='x')
606  {
607  if (!isspace(*Awx)) // comments begin with space
608  {
609  i=0;
610  UtRemCom((char *)Awx);
611  k=atoi(Awx);
612  if (k>1399) continue; // nr zu gross
613  while (Awx[i++]!=' ');
614  pos=1;
615  getst(i,(CHAR *)uifp);
616  y=strlen(uifp);
617  uif[k]=uifp;
618  uifp+=(y+1);
619  }
620  }
621  fclose(uifile);
622  return 1;
623 }
624 
625 
626 int complong(void const *aa,void const *bb)
627 {
628  RECNR a,b;
629  a=*(RECNR *)aa;
630  b=*(RECNR *)bb;
631 
632  if (b<a) return 1;
633  if (a==b) return 0;
634  else return -1;
635 }
636 
637 
638 // Akzentvertauschung Unicode
639 
640 void UtAccent(char *A, char *B, int md) // md=0/1: exp A/a : backw/forw
641 {
642  CHAR *a, *b;
643  a=(CHAR *)A;
644  b=(CHAR *)B;
645  CHAR *xfa=Aextra+8000; // allegro.hpp
646  if (b-a<3) return;
647  if (*xfa==1) return;
648  char ac[256]; // fuer die 256 Bytecodes
649  int j=0,i=256;
650  while (i) ac[--i]=0;
651  char c;
652  while (xfa[j]) ac[xfa[j++]]=1; // Positionen der Akzentcods in ac[] mit 1 markieren
653  j=0;
654  if (md) // exp a : Akzent nach rechts
655  while (a+j<b)
656  {
657  if (ac[a[j]]) // es ist ein accent
658  {
659  i=j+1;
660  while (a[i] && ac[a[i]]) ++i; // es koennen mehr als 1 kombiniert sein!
661  if (!a[i])
662  {
663  --i;
664  while (ac[a[i]]) a[i--]=0;
665  ++j;
666  continue;
667  }
668  c=a[i]; // vertauschen
669  a[i]=a[j];
670  a[j]=c;
671  j=i+1;
672  }
673  else ++j;
674  }
675  else // md==0: exp A, Akzent nach links
676  {
677  j=(int)(b-a)-1; // rueckwaerts vorgehen!
678  while (j)
679  {
680  if (ac[a[j]]) // es ist ein accent
681  {
682  i=j-1;
683  while (i && ac[a[i]]) --i;
684  if (!i)
685  {
686  --j;
687  continue;
688  }
689  c=a[i];
690  a[i]=a[j];
691  a[j]=c;
692  j=i-1;
693  }
694  else --j;
695 
696  }
697  }
698  return;
699 }
700 
701 
702 void UtRecn4(RECNR r,CHAR *addr) // $$ 3.10.92 neu
703 // put r (hi/lo) to addr as 4 bytes
704 {
705  addr[0]=(CHAR)(r/16777216L);
706  r=r%16777216L;
707  addr[1]=(CHAR)(r/65536L);
708  r=r%65536L;
709  addr[2]=(CHAR)(r/256L);
710  addr[3]=(CHAR)(r%256L);
711  return;
712 }
713 
714 void UtKitoa5(int n, CHAR *a) // write n in 5 digits to a, with leading zeros
715 {
716  if (n<100) *a++='0';
717  if (n<1000) *a++='0';
718  if (n<10000) *a++='0';
719  UtKitoa(n,a);
720  return;
721 }
722 
723 void UtKitoa(int n,CHAR s[]) // turn int into a string
724 {
725  sprintf((char *)s,"%d",n);
726  return;
727 }
728 
729 
730 // aufsteigend sortieren: Vergl.Funktion
731 
732 int UtCompstr(void const*a, void const*b)
733 {
734  return strcmp((CHAR*)a,(CHAR*)b);
735 }
736 
737 // absteigend sortieren: Vergl.Funktion
738 
739 int UtComprstr(void const*a, void const*b)
740 {
741  return -strcmp((CHAR*)a,(CHAR*)b);
742 }
743 
744 
745 int UtComplong(void const *aa,void const *bb)
746 {
747  RECNR a,b;
748  a=*(RECNR *)aa;
749  b=*(RECNR *)bb;
750 
751  if (b<a) return 1;
752  if (a==b) return 0;
753  else return -1;
754 }
755 
756 
757 // ---------------------------------------------------------------------
758 // Interne Hilfsfunktionen
759 // ---------------------------------------------------------------------
760 
761 
762 // convert LONG recnr into 4 bytes, big-endian $$20071027
763 void UtLong2char(long rp,CHAR *a)
764 {
765  a[0]=(CHAR)(rp/16777216L);
766  rp=rp%16777216L;
767  a[1]=(CHAR)(rp/65536L);
768  rp=rp%65536L;
769  a[2]=(CHAR)(rp/256L);
770  a[3]=(CHAR)(rp%256L);
771 }
772 
773 
774 // Nur Test
775 #ifdef WIN32
776 // find files, pattern tmplt, put names to fff separated by code 20
777 int ffil(char *tmplt,char *fff) // wird in a99 gebraucht
778 {
779  WIN32_FIND_DATA FFData;
780  HANDLE hFind;
781  int i=1;
782  char str1[256];
783  const char *str2;
784  // * vorn wegnehmen (historisch)
785  if (*tmplt!='*') strcpy(str1,tmplt);
786  else strcpy(str1,tmplt+1);
787 
788  str2=str1;
789  *fff=0;
790 
791 // printf ("Target files %s.\n", str1);
792  hFind = FindFirstFile(str2, &FFData); // 1st file
793  if (hFind == INVALID_HANDLE_VALUE)
794  {
795 // printf ("Invalid File Handle. GetLastError reports %d\n", GetLastError());
796  return (0);
797  }
798  else
799  {
800  int fr=1;
801  while (fr && *FFData.cFileName=='.') fr=FindNextFile(hFind,&FFData);
802  if (!fr) return 0;
803  sprintf(fff,"%s%c",FFData.cFileName,0);
804 // printf("1. %s\n",names[i-1]);
805 
806  while ((fr=FindNextFile(hFind,&FFData))) // nxt files
807  {
808  ++i;
809  sprintf(fff+strlen(fff),"%c%s%c",20,FFData.cFileName,0);
810  }
811  FindClose(hFind);
812  }
813  return i;
814 }
815 #endif
816 
817 /*
818  Copyright 2011 Universitätsbibliothek Braunschweig
819 
820  Licensed under the Apache License, Version 2.0 (the "License");
821  you may not use this file except in compliance with the License.
822  You may obtain a copy of the License at
823 
824  http://www.apache.org/licenses/LICENSE-2.0
825 
826  Unless required by applicable law or agreed to in writing, software
827  distributed under the License is distributed on an "AS IS" BASIS,
828  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
829  See the License for the specific language governing permissions and
830  limitations under the License.
831 */
832