a99  V32.6
allegro Windows Hauptprogramm
 Alle Klassen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
aiprepar.cpp
gehe zur Dokumentation dieser Datei
1 // aiprepar.cpp/.c : Nutzung der Indexdatei vorbereiten, ident. f. .c und .cpp
2 // 1991 / 1995-05-23 / 2011
3 // Copyright 2011 Universitätsbibliothek Braunschweig, more see bottom
4 
5 
6 #include "includes.h"
7 #include "ai-const.h" // allg. Konstanten
8 #include "aisetup.h" // allg. Einstellungen
9 #include "aierrors.h" // Fehlernummern (Konstanten FHL...)
10 #include "aistruc.h" // Strukturen
11 #include "aiglobal.h" // glob. Variablen
12 #include "aideclar.h" // Funktionsdeklarationen
13 
14 
15 // ------------------------------------------
16 // Datenbereiche und Einstellungen einrichten
17 // filbs : Dateipuffer, min 3, mehr als 6 bringt wenig
18 // nregs : Anz. Register, die gleichzeitig existieren koennen
19 // blocs : *128 ist Laenge eines B*-Knotenbereichs, min. 1
20 // kann bei spaeterer Oeffnung der Ind.Datei groesser sein
21 
22 SHORT NewAIX(SHORT filbs,SHORT nregs,SHORT blocs)
23 
24 {
25  SHORT i;
26  aiTRSTR *bloc;
27  aiDATEI *ainmb;
28  SHORT valsiz;
29  CHAR *blocorg,*valoff;
30 
31  /*
32  Nur eine der sich gegenseitig ausschliessenden Optionen
33  LoHi oder HiLo darf gesetzt sein.
34  Versionsbyte fuer Dateikopf setzen
35  */
36 
37 #ifndef LoHi
38 #ifdef HITOLO
39  aiG_opt = (aiLOHI | aiVRS2);
40 #else
41  aiG_opt = (aiHILO | aiVRS2);
42 #endif
43 #ifndef HiLo
44  aiAbort(200);
45 #endif
46 #else
47  aiG_opt = (aiLOHI | aiVRS2);
48 #ifdef HiLo
49  aiAbort(201);
50 #endif
51 #endif
52 
53 // *****************
54 
55 // aiFLAX oder aiIMMED muss gesetzt sein!
56 #ifndef aiFLAX
57 #ifndef aiIMMED
58  aiAbort(202);
59 #endif
60 #endif
61 
62 #ifdef aiFLAX
63 #ifdef aiIMMED
64  aiAbort(203);
65 #endif
66 #endif
67 
68 
69 // -------------------------
70 
71  aiG_fhln = 0;
72  if(filbs < 3 || blocs < 1 || nregs < 0)
73  return(aierro(FHLBADP));
74  if(aiG_ky != 0)
75  return(aierro(FHLISIN));
76 
77  if((aiG_tre = (aiTRSTR *) aispace(filbs,sizeof(aiTRSTR))) == 0)
78  return(aierro(FHLTOBG));
79  if((aiG_ky = (aiDATEI *) aispace(nregs,sizeof(aiDATEI))) == 0)
80  {
81  airels((CHAR *)aiG_tre);
82  return(aierro(FHLTOBG));
83  }
84 
85  valsiz = blocs * aiSCSZ + aiMXLG + sizeof(PTRL);
86  if((aiG_begin = (CHAR *) aispace(filbs,valsiz)) == (CHAR*)NULL)
87  {
88  airels((CHAR *)aiG_ky);
89  aiG_ky = (aiDATEI *)NULL;
90  airels((CHAR *)aiG_tre);
91  return(aierro(FHLTOBG));
92  }
93  valoff = (blocorg = aiG_begin) + aiSTAT;
94 
95  aiG_blocmx = filbs;
96 
97  aiG_datmx = nregs;
98 
99  aiG_spn = blocs;
100  aiG_age = aiG_lru = aiG_virtf = 0;
101  aiG_down[0] = 0;
102 
103  i = 0;
104  bloc = aiG_tre;
105  while(i++ < aiG_blocmx)
106  {
107  bloc->kynum = -1;
108  bloc->coruf = 'n';
109  bloc->acctr = 0;
110  bloc->kntptr = blocorg;
111  bloc->knptr = valoff;
112  blocorg += valsiz;
113  valoff += valsiz;
114  ++bloc;
115  }
116 
117  i = 0;
118  ainmb = aiG_ky;
119  while(i++ < aiG_datmx)
120  {
121  ainmb->lruflg = 0;
122  ainmb->ynv = 'n';
123  ++ainmb;
124  }
125 
126  return(FHLNUL);
127 }
128 
129 // ---------------------------------------
130 // Indexdatei zur Nutzung oeffnen
131 
132 SHORT aiOPEN(SHORT dateinr,CHAR *filnam,SHORT filmod)
133 {
134  aiDATEI *ainmb,*aixf;
135  SHORT opnflg;
136 
137  aiG_fhln = opnflg = NO;
138  ainmb = aiG_ky + dateinr;
139  if(dateinr < 0 || aiG_datmx <= dateinr)
140  aiG_fhln = FHLFNOR;
141  else if(ainmb->ynv != 'n')
142  aiG_fhln = FHLFNUS;
143  else
144  {
145  if((filmod & aiNONSNG) == aiNONSNG)
146  // set aiRDONL flag if aiMULTI & aiRDONL both on
147  filmod &= ~aiMULTI;
148  strcpy((char*)ainmb->datnam,(char*)filnam);
149  ainmb->lruflg = 0;
150  if((ainmb->fdsc = aiopn(ainmb,filmod)) < 0)
151  // does not exist
152  aiG_fhln = FHLNOOP;
153  else
154  {
155  opnflg = YES;
156  if(aiprefrd(ainmb)) ; // no further action if ok
157  else if(ainmb->flgcls < aiDTCL || ainmb->flgcls > aiVTCL)
158  aiG_fhln = FHLUNKF;
159  else if(ainmb->knotsz > (aiG_spn * aiSCSZ))
160  aiG_fhln = FHLKNSZ;
161  else if(ainmb->kylgth > aiMXLG)
162  aiG_fhln = FHLKLEX;
163  else if(ainmb->coruf == aiCPCT)
164  aiG_fhln = FHLCPCT;
165  else if(ainmb->nummb > aiMXREG || ainmb->regnm > 0)
166  aiG_fhln = FHLWRRG;
167  else if(ainmb->coruf || (ainmb->flgcls != aiIXCL && ainmb->nummb > 0))
168  aiG_fhln = FHLFCOR;
169 
170  }
171  }
172 
173  if(aiG_fhln)
174  {
175  if(opnflg) ai_fclose(ainmb,aiSNGL);
176  return(aiG_fhln);
177  }
178  else
179  {
180  if(ainmb->flgcls == aiVTCL) filmod |= aiVLGTH;
181  if(ainmb->fmod != filmod)
182  {
183  if(!((ainmb->fmod = filmod) & aiRDONL) && aiprefwr(ainmb))
184  {
185  opnflg = aiG_fhln;
186  ai_fclose(ainmb,aiSNGL);
187  return(aierro(opnflg));
188  }
189  }
190  ainmb->usrfn = dateinr;
191  ainmb->lruflg = aifixint(ainmb);
192 // ainmb->reserv = 0;
193  aixf = ainmb;
194  while(dateinr <= (ainmb->usrfn + ainmb->nummb))
195  {
196  if(aixf->ynv != 'n' && aixf->ynv != 'm')
197  {
198  ai_fclose(ainmb,aiSNGL);
199  return(aierro(FHLFNUS));
200  }
201  aixf->usrfn = dateinr;
202  if(dateinr > ainmb->usrfn)
203  aixf->fdsc = -1;
204  aixf->ynv = 'y';
205  aixf->knotel = aixf->numlks = 0;
206  aixf->curknt = aiNODNUL;
207  ++dateinr;
208  ++aixf;
209  }
210  return(FHLNUL);
211  }
212 }
213 
214 
215 // ---------------------
216 // Indexdatei schliessen
217 
218 SHORT aiCLOSE(SHORT dateinr,SHORT filmod)
219 {
220  SHORT i;
221  aiDATEI *ainmb;
222  aiTRSTR *bloc;
223  aiDATEI *aixf;
224  SHORT lowi,hghi;
225 
226  aiG_fhln = 0;
227  ainmb = aiG_ky + dateinr;
228  if(dateinr < 0 || aiG_datmx <= dateinr)
229  return(aierro(FHLFNOR));
230  else if(ainmb->ynv == 'n')
231  return(aierro(FHLFNFA));
232  else if(ainmb->regnm > 0)
233  return(aierro(FHLWRRG));
234  else if(ainmb->ynv == 'v')
235  {
236  aixf = ainmb;
237  i = 0;
238  while(i++ <= ainmb->nummb)
239  {
240  aixf->ynv = 'n';
241  ++aixf;
242  }
243  return(FHLNUL);
244  }
245 
246 
247  if(ainmb->flgcls != aiDTCL)
248  {
249  lowi = ainmb->usrfn;
250  hghi = lowi + ainmb->nummb;
251  bloc = aiG_tre;
252  i = 0;
253  while(i < aiG_blocmx)
254  {
255  if(bloc->kynum >= lowi && bloc->kynum <= hghi)
256  {
257  if(bloc->coruf == 'y')
258  {
259  if(ainmb->coruf)
260  {
261  if(aiknowri(bloc))
262  return(aiG_fhln);
263  }
264  else
265  aiAbort(206);
266  }
267  bloc->kynum = -1;
268  }
269  ++i;
270  ++bloc;
271  }
272  }
273  aixf = ainmb;
274  i = 0;
275  while(i++ <= ainmb->nummb)
276  {
277  if(aixf->ynv != 'm') aixf->ynv = 'n';
278  ++aixf;
279  }
280  if(ainmb->coruf)
281  {
282  ainmb->coruf = NO;
283  if(aiprefwr(ainmb))
284  return(aiG_fhln);
285  }
286 
287  if(ai_fclose(ainmb,filmod) < 0)
288  return(aierro(FHLCLSF));
289  return(FHLNUL);
290 }
291 
292 // -----------------------
293 // Indexdatei vergroessern
294 
295 PTRL aidataxf(aiDATEI *ainmb,unsigned int rsize)
296 { // aidataxf nimmt im Mehrplatzbetrieb an, dass Dateikopf gesperrt ist
297  PTRL rsult,oldval;
298 
299  PTRL oldphy;
300  SHORT i;
301 
302  ainmb -= ainmb->regnm;
303 
304  rsult = (oldval = ainmb->lbow) + 1;
305  ainmb->lbow += rsize;
306 
307  oldphy = ainmb->lbof;
308 
309  if(oldval > ainmb->lbow)
310  {
311  aierro(FHLFULL);
312  return(0);
313  }
314  else if(ainmb->lbow <= ainmb->lbof)
315  return(rsult);
316  else if((unsigned int)ainmb->xtdfs <= rsize)
317  {
318  ainmb->lbof = ainmb->lbow;
319  return(rsult);
320  }
321  else // Datei um eine Einheit vergroessern und dir Eintrag sichern
322  {
323  if(ainmb->lbof < (ainmb->xtdfs - 1))
324  ainmb->lbof = ainmb->xtdfs - 1;
325  else
326  ainmb->lbof += ainmb->xtdfs;
327 
328  if(ainmb->lbof < ainmb->lbow)
329  {
330  // overflow
331  ainmb->lbof = ainmb->lbow;
332  return(rsult);
333  }
334  i = 0;
335  while(i < aiBFSZ)
336  { aiG_rdwr[i] = aiDELF; ++i; }
337  i = (ainmb->lbof - oldphy++) / aiBFSZ;
338  while(i-- > 0)
339  {
340  if(airw(aiWRT,ainmb,oldphy,(CHAR *)aiG_rdwr,aiBFSZ))
341  break;
342  oldphy += aiBFSZ;
343  }
344  if(i = ainmb->lbof - oldphy + 1)
345  {
346  if(aiG_fhln || airw(aiWRT,ainmb,oldphy,(CHAR *)aiG_rdwr,i))
347  {
348  // couldn't extend by a chunk
349  aiG_fhln = 0;
350  ainmb->lbof = ainmb->lbow;
351  return(rsult);
352  }
353  }
354  if(aisav(ainmb)) return(0);
355  return(rsult);
356  }
357 }
358 
359 
360 /* --------------------------------------------------------------
361  Gueltige Dateinummer checken und ermitteln, ob die Datei ainmb
362  aktiviert ist.
363  Return: 0 im Fehlerfall
364 */
365 
367 {
368  aiDATEI *rsult,*ainmb;
369  SHORT nmreg;
370 
371  aiG_fhln = FHLNUL;
372 
373  if(aiG_datmx == 0)
374  {
375  aierro(FHLININ);
376  return((aiDATEI *)NULL);
377  }
378  else
379 
380  if(dateinr < 0 || aiG_datmx <= dateinr) // dateinr out of range
381  {
382  aierro(FHLFNOR);
383  return((aiDATEI *)NULL);
384  }
385  else
386  rsult = aiG_ky + dateinr;
387 
388  switch (rsult->ynv)
389  {
390  case 'n':
391  aiG_fhln = FHLFNFA;
392  return((aiDATEI *)NULL);
393  case 'y':
394  rsult->lruflg = aifixint(rsult);
395  return(rsult);
396  case 'v':
397  case 'w':
398 
399  ainmb = rsult - rsult->regnm;
400 
401  nmreg = ainmb->nummb;
402  ainmb->lruflg = 0;
403  if((ainmb->fdsc = aiopn(ainmb,ainmb->fmod)) < 0)
404  {
405  aiG_fhln = FHLVRTC;
406  return((aiDATEI *)NULL);
407  }
408  else
409  {
410  ainmb->lruflg = aifixint(rsult);
411  dateinr = 0;
412  while(dateinr++ <= nmreg)
413  {
414  ainmb->ynv = ainmb->ynv == 'w' ? 'm' : 'y';
415  ++ainmb;
416  }
417  return(rsult);
418  }
419  default:
420  aiAbort(222);
421  }
422  return(0);
423 }
424 
425 // -----------------------
426 // wurde Header geaendert? Updateflag checken
427 
429 {
430  ainmb -= ainmb->regnm;
431 
432  if(ainmb->fmod & aiRDONL)
433  return(aiG_fhln = FHLWRRD);
434  else
435  return(FHLNUL);
436 }
437 
438 // ******* Hilfsfunktionen *********************
439 // ---------------
440 
442 {
443  aiDATEI *ainmb; // bezieht sich auf die Registerdateien
444  aiDATEI *fndnum; // die sich im Index befinden
445  SHORT i;
446  uSHORT ailuse; // Nr. der zuletzt genutzten
447 
448  ainmb = aiG_ky;
449  ailuse = aiMXA;
450  fndnum = (aiDATEI *)NULL;
451  i = 0;
452  while(i++ < aiG_datmx)
453  {
454  if(ainmb->lruflg && ainmb->lruflg <= ailuse &&
455  ainmb->ynv == 'y' && ainmb->regnm < 1 &&
456  !(ainmb->fmod & aiPERM) && !ainmb->numlks)
457  ailuse = (fndnum = ainmb)->lruflg;
458  ++ainmb;
459  }
460  if((ainmb = fndnum) == 0) return(NO);
461  else
462  {
463  if(aiCLOSE(ainmb->usrfn,ainmb->fmod)) return(NO);
464 
465  ainmb->lruflg = 0;
466  i = 0;
467  while(i++ <= fndnum->nummb)
468  {
469  ainmb->ynv = ainmb->ynv == 'm' ? 'w' : 'v';
470  ++ainmb;
471  }
472  return(YES);
473  }
474 }
475 
476 // ----------------------------
477 
479 {
480  aiDATEI *calnum;
481  SHORT i;
482  uSHORT aimndage;
483 
484  ainmb -= (calnum = ainmb)->regnm;
485 
486  if(ainmb->fmod & aiPERM) // keine virt. Datei
487  return(0);
488  else if(++aiG_lru) // Dann ist Alter der Datei nicht geaendert
489  return(calnum->lruflg = aiG_lru);
490 
491  i = 0;
492  ainmb = aiG_ky;
493  aimndage = aiMXA;
494  while(i++ < aiG_datmx)
495  {
496  if(ainmb->lruflg && ainmb->lruflg <= aimndage && ainmb->regnm < 1)
497  aimndage = ainmb->lruflg;
498  ++ainmb;
499  }
500  aiG_lru = aiMXA - (--aimndage);
501  ainmb = aiG_ky;
502  i = 0;
503  while(i++ < aiG_datmx)
504  { if(ainmb->lruflg)
505  ainmb->lruflg -= aimndage;
506  ++ainmb;
507  }
508  return(calnum->lruflg = ++aiG_lru);
509 }
510 
511 // ------------------------------------
512 // Ist Flag coruf gesetzt? Sonst setzen
513 
515 {
516 #ifdef aiFLAX
517  ainmb -= ainmb->regnm;
518 
519  if(!(ainmb->coruf))
520  {
521  ainmb->coruf = aiUPDD;
522  if(aiprefwr(ainmb))
523  return(aiG_fhln);
524  }
525 #endif
526  return(FHLNUL);
527 }
528 
529 
530 #ifdef HITOLO
531 // BigEndian? Dann umdrehen
532 void aiwritrv(CHAR *tp, SHORT wrdcnt)
533 { // nimmt an, dass aiflip schon ausgef. wurde
534  CHAR ch1,ch2;
535 
536  while(wrdcnt-- > 0)
537  {
538  ch1 = *tp++;
539  ch2 = *tp++;
540  *(tp - 2) = *tp;
541  *tp++ = ch1;
542  *(tp - 2) = *tp;
543  *tp++ = ch2;
544  }
545 }
546 
547 void aiprefrv(aiDATEI *ainmb)
548 {
549  ai_flip((CHAR *)ainmb,8);
550  ai_flip((CHAR *)&ainmb->entcnt,22);
551  aiwritrv((CHAR *)&ainmb->entcnt,7);
552 }
553 
554 #endif
555 
556 // ---------------
557 // Dateikopf lesen
558 
560 {
561  SHORT i;
562  SHORT nmreg;
563  PTRL airecnum;
564 
565  if(airw(aiREAD,ainmb,airecnum = 0,(CHAR *)ainmb,aiHDSIZ))
566  return(aiG_fhln);
567 #ifdef HITOLO
568  aiprefrv(ainmb);
569 #endif
570  if(ainmb->flgcls == aiIXCL)
571  {
572  nmreg = ainmb->nummb;
573  i = 1;
574  while(i <= nmreg)
575  {
576  airecnum += aiHDSIZ;
577  if(airw(aiREAD,ainmb,airecnum,(CHAR *)(ainmb + i),aiHDSIZ))
578  return(aiG_fhln);
579 #ifdef HITOLO
580  aiprefrv(ainmb + i);
581 #endif
582  ++i;
583  }
584  }
585  return(FHLNUL);
586 }
587 
588 
589 // -------------------
590 // Dateikopf schreiben
591 
593 {
594  SHORT i;
595  SHORT nmreg;
596  PTRL airecnum;
597 
598  ainmb -= ainmb->regnm;
599 
600  nmreg = ainmb->nummb;
601  i = 0;
602  airecnum = 0;
603  while(i <= nmreg)
604  {
605 #ifdef HITOLO
606  aicopy(aiG_rdwr,ainmb + i,aiHDSIZ);
608  if(airw(aiWRT,ainmb,airecnum,(CHAR *)aiG_rdwr,aiHDSIZ))
609  return(aiG_fhln);
610 #else
611  if(airw(aiWRT,ainmb,airecnum,(CHAR *)(ainmb + i),aiHDSIZ))
612  return(aiG_fhln);
613 #endif
614  ++i;
615  airecnum += aiHDSIZ;
616  }
617 
618  return(FHLNUL);
619 }
620 
621 
622 // -----------------------------
623 // aibloc in die Datei schreiben
624 // Return: !=0 im Fehlerfall
625 
626 
627 SHORT aiknowri(aiTRSTR *aibloc ) // aibloc ist der zu schreibende Knoten
628 {
629  aiINDX *aixf; /* key number pointer */
630  SHORT membno;
631 
632 // Dateizeiger und Registernummer setzen
633 
634  membno = (aixf = aiG_ky + aibloc->kynum)->regnm;
635  if(membno > 0)
636 
637  aixf -= membno;
638 
639 // Registernummer checken
640 
641  if(aibloc->regnr != membno)
642  aiAbort(230);
643 
644 // Statusinfo des Knotens nach aibloc kopieren
645 
646  aicopy((char *)aibloc->kntptr,(char *)&aibloc->rgtkey,aiSTAT);
647 
648 
649 #ifdef HITOLO
650  ai_flip(aibloc->kntptr,6);
651  aiwritrv(aibloc->kntptr,2);
652 #endif
653 
654 // Knoten wegschreiben
655 
656  if(airw(aiWRT,aixf,aibloc->knotid,(CHAR *)aibloc->kntptr,aixf->knotsz))
657  return(aiG_fhln);
658 
659  aibloc->coruf = 'n';
660 
661 #ifdef aiIMMED
662 
663 // Statusdaten so aendern, dass nachfolgende Aufrufe von aiknoget nicht
664 // den Knoten als gueltig ansehen
665 
666  if(aixf->fmod & aiMULTI)
667  {
668  aibloc->kynum = -1;
669  aibloc->knotid = -1;
670  }
671 #endif
672 
673  return(FHLNUL);
674 }
675 
676 
677 /*
678  Copyright 2011 Universitätsbibliothek Braunschweig
679 
680  Licensed under the Apache License, Version 2.0 (the "License");
681  you may not use this file except in compliance with the License.
682  You may obtain a copy of the License at
683 
684  http://www.apache.org/licenses/LICENSE-2.0
685 
686  Unless required by applicable law or agreed to in writing, software
687  distributed under the License is distributed on an "AS IS" BASIS,
688  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
689  See the License for the specific language governing permissions and
690  limitations under the License.
691 */
692