a99  V32.6
allegro Windows Hauptprogramm
 Alle Klassen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
aiefunc1.cpp
gehe zur Dokumentation dieser Datei
1 // aiefunc1.cpp/.c : Elementarfunktionen Teil 1, ident. f. .c und .cpp
2 // 1991 / 1995-05-23 / 2011
3 // Copyright 2011 Universitätsbibliothek Braunschweig, more see bottom
4 
5 // Benutzt Funktionen aus Teil 2 (aiefunc2.c)
6 
7 
8 #include "includes.h" // einige Konventionen
9 #include "ai-const.h" // allg. Konstanten
10 
11 // EXTERN ausschalten, weil Werte hier gesetzt werden
12 #define EXTERN
13 
14 #include "aisetup.h" // allg. Einstellungen
15 #include "aierrors.h" // Fehlernummern
16 #include "aistruc.h" // Strukturen
17 #include "aiglobal.h" // glob. Variablen
18 #include "aideclar.h" // Funktionsdeklarationen
19 
20 #ifdef WIN32 // ve:$$970120
21 #include <io.h> // wegen unlock(..)
22 #include <sys\locking.h> // ---- MICROSOFT ----
23 #endif
24 
25 #define LSHIFT 24 // maxzahl virtueller Sperren, nicht aendern
26 #define LOOPC 3000 // Schleifenzaehler beim Warten auf Sperre
27 
28 #ifdef WIN32
29 #include <io.h>
30 #include <share.h>
31 #include <sys\stat.h> // From Borland (obs.?)
32 #endif
33 
34 #define O_DENYNONE 0x40 // fehlt in share.h
35 
36 // --------------------------
37 // aiopn : Indexdatei oeffnen
38 
39 #ifdef WIN32
40 int aiopn(aiDATEI *ainmb, SHORT modus)
41 // modus : aiSNGL oder aiMULTI
42 {
43  int rsult;
44  int accflg,mulflg;
45 
46  ainmb->cafp = 0L;
47  accflg = BUPDATE;
48 #ifdef aiIMMED // SH_ siehe <share.h>
49  if(modus & aiMULTI) // Aend. 6.6.96 ev
50  mulflg = O_DENYNONE; // vorher SH_DENYRW
51  else if(modus & aiRDONL)
52  {
53  mulflg = O_DENYNONE; // vorher SH_DENYWR
54  accflg = (O_BINARY | O_RDONLY);
55  }
56  else
57  mulflg = O_DENYNONE;
58 #else
59  mulflg = O_DENYNONE;
60 #endif
61 
62  if(!(modus & aiPERM) && aiG_virtf >= aiMXVF)
63  aiendv();
64  if((rsult = sopen ((char *)ainmb->datnam,accflg , mulflg,S_IREAD|S_IWRITE)) < 0)
65  if(aiendv() == YES)
66  rsult = sopen((char *)ainmb->datnam,accflg, mulflg,S_IREAD|S_IWRITE);
67  if(!(modus & aiPERM) && rsult >= 0)
68  aiG_virtf++;
69 
70  return(rsult);
71 }
72 #else // Linux/UNIX
73 
74 int aiopn(aiDATEI *ainmb, SHORT modus)
75 {
76  int rsult;
77  int accflg;
78  int i;
79  SHORT aiendv();
80 
81  ainmb->cafp = 0L;
82 
83  accflg = O_RDWR;
84 
85 
86  if(modus & aiRDONL)
87  accflg = O_RDONLY;
88 
89  if(!(modus & aiPERM) && aiG_virtf >= aiMXVF)
90  aiendv();
91 
92  if((rsult = open((char *)ainmb->datnam,accflg)) < 0)
93  if(aiendv() == YES)
94  rsult = open((char *)ainmb->datnam,accflg);
95 
96  /* if exclusive open, obtain lock on entire file */
97  if(rsult > -1 && !(modus & aiNONSNG) &&
98  lockf(rsult,F_TLOCK,0L)) {
99  close(rsult);
100  return(-1);
101  }
102  /* obtain lock on entire file if exclusive open */
103  if(rsult > -1 && !(modus & aiNONSNG)) {
104  lseek(rsult,(long)(ainmb->cafp = aiHDSIZ),0);
105  if(lockf(rsult,F_TLOCK,0L)) {
106  close(rsult);
107  return(-1);
108  }
109  } else if(rsult > -1 && (modus & aiNONSNG)) {
110  /* check file type to see if index: no lock on index */
111  if(read(rsult,ainmb,aiHDSIZ) != aiHDSIZ) {
112  close(rsult);
113  return(-1);
114  }
115  else
116  {
117 #ifdef HITOLO
118  aiprefrv(ainmb);
119 #endif
120  ainmb->cafp = aiHDSIZ;
121  }
122  if(ainmb->flgcls != aiIXCL)
123  {
124  i = aiHDSIZ;
125  while( i < 128)
126  {
127  lseek(rsult,(long)(ainmb->cafp = i),0);
128  if(lockf(rsult,F_TLOCK,1L) == 0)
129  break;
130  ++i;
131  }
132  if(i >= 128) {
133  close(rsult);
134  return(-1);
135  }
136  }
137  }
138 
139  if(!(modus & aiPERM) && rsult >= 0)
140  aiG_virtf++;
141 
142  return(rsult);
143 }
144 
145 #endif
146 
147 // ------------------------------------------------------------
148 // aicrt : Indexdatei als Datei anlegen
149 
150 #ifdef WIN32
151 int aicrt(aiDATEI *ainmb)
152 {
153  int rsult;
154 
155  SHORT aiendv();
156 
157  ainmb->cafp = 0L;
158  if(!(ainmb->fmod & aiPERM) && aiG_virtf >= aiMXVF)
159  aiendv();
160 
161  if((rsult = open((char*)ainmb->datnam,
162  BCREATE,(S_IREAD | S_IWRITE))) < 0)
163  if(aiendv() == YES)
164  rsult = open((char*)ainmb->datnam,
165  BCREATE,
166  (S_IREAD | S_IWRITE));
167 
168  if(!(ainmb->fmod & aiPERM) && rsult >= 0)
169  aiG_virtf++;
170 
171  return(rsult);
172 }
173 #else
174 int aicrt(aiDATEI *ainmb)
175 {
176  int rsult;
177  SHORT aiendv();
178 
179  ainmb->cafp = 0L;
180  if(!(ainmb->fmod & aiPERM) && aiG_virtf >= aiMXVF)
181  aiendv();
182 
183  if((rsult = creat((char *)ainmb->datnam,BCREATE)) < 0)
184  if(aiendv() == YES)
185  rsult = creat((char *)ainmb->datnam,BCREATE);
186 
187  if(!(ainmb->fmod & aiNONSNG) && rsult >= 0)
188  aiG_virtf++;
189  return(rsult);
190 }
191 #endif
192 
193 
194 // ------------------------------------------------------------
195 
197 {
198 
199  if(ai_fclose(ainmb,ainmb->fmod))
200  return(aierro(FHLNOSV));
201  else if((ainmb->fdsc = aiopn(ainmb,ainmb->fmod)) < 0)
202  return(aierro(FHLNOSV));
203  else
204  return(FHLNUL);
205 }
206 
207 
208 
209 #ifdef WIN32
210 /* ve:$$ 970120
211  der WIN32 Compiler kennt eine andere Locking-Funktion als
212  Borland, Watcom. Hierfuer benoetigt man die Hilfsfunktion aifpos,
213  die den Filepointer auf die Position airecnum setzt.
214 */
215 
216 SHORT ailseek(int cfd,long airecnum)
217 {
218  long lseek();
219  long rsult;
220 
221  if((rsult = _lseek(cfd,airecnum,0 )) == -1L)
222  {
223  return(FHLSEEK); // return(FHLNUL); //$$020524
224  }
225  else
226  return(FHLNUL);
227 }
228 #endif
229 
230 // -------------------
231 // Indexknoten sperren
232 
233 
234 #ifdef WIN32
235 SHORT aiLok(RECNR knot, aiINDX *aixf) // knot == 0 => header
236 {
237  /*
238  Knotensperre ist ohne Gefahr von Deadlocks. Wenn deshalb
239  eine Sperre misslingt, erzwingt diese Funktion eine kurze Pause und
240  versucht es nochmal. Der LOOPC-Wert erlaubt eine lange Schleife,
241  wenn in den Sperrfunktionen ein Fehler auftritt. An sich sollte
242  eine while-Schleife ja nie unbegrenzt laufen!
243  */
244 
245 #ifdef aiIMMED
246 
247  SHORT lc,tries;
248 
249  tries = 0;
250  aixf -= aixf->regnm;
251  if(!(aixf->fmod & aiNONSNG))
252  return(FHLNUL);
253 
254  /*
255  Ein Sperrbereich wird abgebildet auf einen Pseudobereich im virtuellen
256  File und die Sperre wird auf Datei 0 gemacht (deren Steuerbereich
257  die globale Variable aiG_ky angibt).
258  */
259  if(aixf->flgcls != aiVTCL)
260  knot /= aixf->knotsz;
261  knot |= ((RECNR) aixf->usrfn << LSHIFT);
262 #ifdef WIN32
263  if(ailseek(aiG_ky->fdsc,knot))
264  return(aierro(FHLSEEK));
265  while (locking(aiG_ky->fdsc,LK_NBLCK,1L))
266 #else
267  while (lock(aiG_ky->fdsc,knot,1L))
268 #endif
269  if(tries++ > LOOPC)
270  return(aierro(FHLNOLK));
271  else
272  /* delay and try again */
273  lc=0;
274  while(lc++ < LOOPC)
275  ;
276  return(FHLNUL);
277 #else
278  return(FHLNUL);
279 #endif
280 
281 }
282 #else
283 SHORT aiLok(RECNR knot, aiINDX *aixf) // knot == 0 => header
284 {
285 #ifdef aiIMMED
286  aixf -= aixf->regnm;
287  if(!(aixf->fmod & aiNONSNG))
288  return(FHLNUL);
289 
290  if(aifpos(aixf,knot))
291  return(aierro(FHLSEEK));
292  if(lockf(aixf->fdsc,F_LOCK,1L))
293  return(aierro(FHLNOLK));
294  else {
295  aixf->numlks++;
296  return(FHLNUL);
297  }
298 #else
299  return(ALL_OK);
300 #endif
301 }
302 #endif
303 
304 
305 // ----------------
306 // Knoten freigeben
307 
308 #ifdef WIN32
309 SHORT aiUnlk(RECNR knot, aiINDX *aixf)
310 {
311 
312 #ifdef aiIMMED
313  aixf -= aixf->regnm;
314  if(!(aixf->fmod & aiNONSNG))
315  return(FHLNUL);
316 
317  if(aixf->flgcls != aiVTCL)
318  knot /= aixf->knotsz;
319  knot |= ((RECNR) aixf->usrfn << LSHIFT);
320 #ifdef WIN32 // ve: $$970120
321  if(ailseek(aiG_ky->fdsc,knot))
322  return(aierro(FHLSEEK));
323  else if(_locking(aiG_ky->fdsc,LK_UNLCK,1L)) // $$020524
324 #else
325  if(unlock(aiG_ky->fdsc,knot,1L))
326 #endif
327  return(aierro(FHLNOLU));
328  else
329  return(FHLNUL);
330 #else
331  return(FHLNUL);
332 #endif
333 
334 }
335 
336 #else
337 SHORT aiUnlk(RECNR knot, aiINDX *aixf)
338 {
339 
340 #ifdef aiIMMED
341  aixf -= aixf->regnm;
342  if(!(aixf->fmod & aiNONSNG))
343  return(FHLNUL);
344 
345  if(aixf->numlks)
346  aixf->numlks--;
347  if(aifpos(aixf,knot))
348  return(aierro(FHLSEEK));
349  else if(lockf(aixf->fdsc,F_ULOCK,1L))
350  return(aierro(FHLNOLU));
351  else
352  return(FHLNUL);
353 #else
354  return(FHLNUL);
355 #endif
356 }
357 
358 
359 #endif
360 
361 /*
362  Copyright 2011 Universitätsbibliothek Braunschweig
363 
364  Licensed under the Apache License, Version 2.0 (the "License");
365  you may not use this file except in compliance with the License.
366  You may obtain a copy of the License at
367 
368  http://www.apache.org/licenses/LICENSE-2.0
369 
370  Unless required by applicable law or agreed to in writing, software
371  distributed under the License is distributed on an "AS IS" BASIS,
372  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
373  See the License for the specific language governing permissions and
374  limitations under the License.
375 */
376