![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parse2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / quipu|
Return to parse2.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / quipu |
1.1 root 1: /* parse2.c - */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/quipu/RCS/parse2.c,v 7.3 90/07/09 14:46:27 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/quipu/RCS/parse2.c,v 7.3 90/07/09 14:46:27 mrose Exp $
9: *
10: *
11: * $Log: parse2.c,v $
12: * Revision 7.3 90/07/09 14:46:27 mrose
13: * sync
14: *
15: * Revision 7.2 90/01/11 18:37:23 mrose
16: * real-sync
17: *
18: * Revision 7.1 89/12/19 16:20:42 mrose
19: * sync
20: *
21: * Revision 7.0 89/11/23 22:17:57 mrose
22: * Release 6.0
23: *
24: */
25:
26: /*
27: * NOTICE
28: *
29: * Acquisition, use, and distribution of this module and related
30: * materials are subject to the restrictions of a license agreement.
31: * Consult the Preface in the User's Manual for the full terms of
32: * this agreement.
33: *
34: */
35:
36: #include "quipu/util.h"
37: #include "quipu/entry.h"
38: #include "quipu/config.h"
39: #include "cmd_srch.h"
40: #include "quipu/malloc.h"
41: #ifdef TURBO_DISK
42: #include <gdbm.h>
43: #endif
44:
45: Entry getentry_block_aux (), get_entry_aux();
46: extern LLog * log_dsap;
47: char * getline ();
48: int rdn_print ();
49: int master_edbs = 0;
50: int slave_edbs = 0;
51:
52: #ifdef TURBO_DISK
53: extern datum turbo_header_key;
54: #endif
55:
56: Entry getentry_block (p_parent,fname)
57: Entry p_parent;
58: char * fname;
59: {
60: #ifdef TURBO_DISK
61: GDBM_FILE db;
62: static char gfname[1024];
63: int save_heap;
64:
65: strcpy(gfname, fname);
66: strcat(gfname, ".gdbm");
67: save_heap = mem_heap;
68: GENERAL_HEAP;
69: db = gdbm_open(gfname, 0, GDBM_READER, 0, 0);
70: mem_heap = save_heap;
71: return getentry_block_aux (p_parent, gfname, db);
72: #else
73: return getentry_block_aux (p_parent,fname, fopen (fname, "r"));
74: #endif
75: }
76:
77: Entry getentry_block_aux (p_parent,fname,file)
78: Entry p_parent;
79: char * fname;
80: #ifdef TURBO_DISK
81: GDBM_FILE file;
82: #else
83: FILE *file;
84: #endif
85: {
86: extern char * parse_file;
87: extern int parse_status;
88: extern int parse_line;
89: Entry entryptr;
90: int dtype;
91: char *version;
92: Entry get_entries_aux ();
93: extern int errno;
94:
95: if (file == NULL) {
96: LLOG (log_dsap,LLOG_NOTICE,("WARNING - Can't open \"%s\" (%d)- should I be able to ?",fname,errno));
97: return (NULLENTRY);
98: }
99:
100: LLOG (log_dsap,LLOG_NOTICE,("Loading \"%s\"",fname));
101:
102: parse_status = 0;
103: parse_line = 0;
104: parse_file = fname;
105:
106: if (get_header (file,&dtype,&version) != OK) {
107: parse_line = 0;
108: parse_error ("File %s not loaded",fname);
109: parse_file = NULLCP;
110: #ifdef TURBO_DISK
111: save_heap = mem_heap;
112: GENERAL_HEAP;
113: (void) gdbm_close (file);
114: mem_heap = save_heap;
115: #else
116: (void) fclose (file);
117: #endif
118: return (NULLENTRY);
119: }
120:
121: entryptr = get_entries_aux (file,p_parent,version,dtype);
122:
123: if ((parse_status != 0) || (entryptr == NULLENTRY)) {
124: parse_line = 0;
125: parse_error ("File %s not loaded",fname);
126: parse_file = NULLCP;
127: #ifdef TURBO_DISK
128: save_heap = mem_heap;
129: GENERAL_HEAP;
130: (void) gdbm_close (file);
131: mem_heap = save_heap;
132: #else
133: (void) fclose (file);
134: #endif
135: return (NULLENTRY);
136: }
137:
138: if ( p_parent != NULLENTRY ) {
139: p_parent->e_edbversion = version;
140: if ((dtype == E_DATA_MASTER) || (dtype == E_TYPE_SLAVE))
141: p_parent->e_allchildrenpresent = TRUE;
142: }
143:
144: parse_file = NULLCP;
145:
146: if (dtype == E_DATA_MASTER)
147: master_edbs++;
148: if (dtype == E_TYPE_SLAVE)
149: slave_edbs++;
150:
151: #ifdef TURBO_DISK
152: save_heap = mem_heap;
153: GENERAL_HEAP;
154: (void) gdbm_close (file);
155: mem_heap = save_heap;
156: #else
157: (void) fclose (file);
158: #endif
159: return (entryptr);
160: }
161:
162: #ifdef TURBO_DISK
163:
164: get_header (db, typeptr, versionptr)
165: GDBM_FILE db;
166: int *typeptr;
167: char **versionptr;
168: {
169: char *v;
170: datum h;
171: int save_heap;
172: static CMD_TABLE cmd_header[] = {
173: "MASTER", E_DATA_MASTER,
174: "SLAVE", E_TYPE_SLAVE,
175: "CACHE", E_TYPE_CACHE_FROM_MASTER,
176: 0, -1,
177: };
178: extern char *parse_entry;
179:
180: save_heap = mem_heap;
181: GENERAL_HEAP;
182:
183: parse_entry = turbo_header_key.dptr;
184: if (db == NULL) {
185: parse_error("NULL dbm file!!!", NULLCP);
186: mem_heap = save_heap;
187: return(NOTOK);
188: }
189:
190: h = gdbm_fetch(db, turbo_header_key);
191: if (h.dptr == NULL) {
192: parse_error("File has no header!!!", NULLCP);
193: mem_heap = save_heap;
194: return(NOTOK);
195: }
196:
197: v = index(h.dptr, '\n');
198: if (v == NULLCP) {
199: parse_error("Bad file header", NULLCP);
200: mem_heap = save_heap;
201: return(NOTOK);
202: }
203: *v++ = '\0';
204:
205: if ((*typeptr = cmd_srch(h.dptr, cmd_header)) == -1) {
206: parse_error("File type %s not recognised", h.dptr);
207: mem_heap = save_heap;
208: return(NOTOK);
209: }
210:
211: if (*v == '\0') {
212: parse_error("No version specified", NULLCP);
213: mem_heap = save_heap;
214: return(NOTOK);
215: }
216: *versionptr = strdup(v);
217: free(h.dptr);
218:
219: mem_heap = save_heap;
220: return(OK);
221: }
222:
223: #else
224:
225: get_header (file,typeptr,versionptr)
226: FILE * file;
227: int * typeptr;
228: char ** versionptr;
229: {
230: char * ptr;
231: static CMD_TABLE cmd_header [] = {
232: "MASTER", E_DATA_MASTER,
233: "SLAVE", E_TYPE_SLAVE,
234: "CACHE", E_TYPE_CACHE_FROM_MASTER,
235: 0, -1,
236: };
237:
238: if ((ptr = getline (file)) == NULLCP) {
239: parse_error ("NULL file !!!",NULLCP);
240: return (NOTOK);
241: }
242:
243: if ((*typeptr = cmd_srch (ptr,cmd_header)) == -1) {
244: parse_error ("File type %s not recognised",ptr);
245: return (NOTOK);
246: }
247:
248: if ((ptr = getline (file)) == NULLCP) {
249: parse_error ("No version specified",NULLCP);
250: return (NOTOK);
251: }
252: *versionptr = strdup (ptr);
253:
254: return (OK);
255: }
256:
257: #endif
258:
259: /* ARGSUSED */
260: Entry get_entries_aux (file,parent,version,dtype)
261: #ifdef TURBO_DISK
262: GDBM_FILE file;
263: #else
264: FILE * file;
265: #endif
266: Entry parent;
267: char * version;
268: int dtype;
269: {
270: Entry eptr = NULLENTRY;
271: Entry top = NULLENTRY;
272: Entry trail;
273: Entry find_sibling();
274:
275: #ifdef TURBO_DISK
276: extern int dbmeof;
277: #endif
278: #ifdef TURBO_LOAD
279: if ( ! turbo_start(file)) {
280: parse_error ("Turbo load failed",NULLCP);
281: return NULLENTRY;
282: }
283: #endif
284:
285: #ifdef TURBO_DISK
286: dbmeof = 0;
287: while (dbmeof == 0) {
288: #else
289: while (feof(file) == 0) {
290: #endif
291: if ((eptr = get_entry_aux (file,parent,dtype)) == NULLENTRY)
292: continue;
293: if ( top == NULLENTRY) {
294: top = eptr;
295: trail = eptr;
296: } else {
297: #ifdef TURBO_LOAD
298: if ( turbo_insert(eptr->e_name) != OK )
299: #else
300: if (find_sibling (eptr->e_name,top) != NULLENTRY)
301: #endif
302: {
303: pslog (log_dsap,LLOG_EXCEPTIONS,"Duplicate entry for",rdn_print,(caddr_t)eptr->e_name);
304: parse_error ("Non Unique RDN",NULLCP);
305: }
306: trail->e_sibling = eptr;
307: trail = eptr;
308: }
309: }
310:
311: #ifdef TURBO_LOAD
312: turbo_end();
313: #endif
314:
315: return (top);
316: }
317:
318:
319: Entry get_entries (file,parent,version,dtype)
320: FILE * file;
321: Entry parent;
322: char * version;
323: int dtype;
324: {
325: extern int parse_status;
326: extern int parse_line;
327:
328: parse_status = 0;
329: parse_line = 0;
330:
331: return (get_entries_aux (file,parent,version,dtype));
332: }
333:
334: Entry find_sibling (object,start)
335: RDN object;
336: Entry start;
337: {
338: if (start == NULLENTRY)
339: return (NULLENTRY);
340:
341: while (rdn_cmp (start->e_name, object) != OK) {
342: start = start->e_sibling ;
343: if ( start == NULLENTRY )
344: return (NULLENTRY);
345: }
346: return (start);
347: }
348:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.