![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to control.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / parser|
Return to control.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / parser |
1.1 root 1: # include <ingres.h>
2: # include <aux.h>
3: # include <symbol.h>
4: # include <tree.h>
5: # include "parser.h"
6: # include <pv.h>
7: # include "scanner.h"
8: # include <sccs.h>
9:
10: SCCSID(@(#)control.c 7.1 2/5/81)
11:
12: /*
13: ** CONTROL.C -- -- collection of control functions for the parser
14: **
15: ** These routines administrate the operation of the parser for internal
16: ** sequencing. There are 2 pairs of routines, one pair for each
17: ** quel statement, and one for each go-block, and there is one
18: ** routine to finish retrieve statements.
19: **
20: ** Defines:
21: ** startgo -- initialize for a go-block
22: ** init_quelst -- initialize for a quel statement
23: ** endquelst -- clean up after a quel statement
24: ** endretrieve -- clean up after a retrieve
25: ** endgo -- clean up after a go-block
26: **
27: ** Trace Flags:
28: ** control.c ~~ 48, 49
29: **
30: ** History:
31: ** 6 Jun 80 (jiw) modified and redocumented for 6.3
32: ** 15 Jan 79 (rick) collected and documented more
33: ** ancient history
34: */
35:
36: /*
37: ** INIT_QUELST -- set vbles for default mode before each quel statement
38: **
39: ** Parameters:
40: ** none
41: **
42: ** Returns:
43: ** nothing
44: **
45: ** Trace Flags:
46: ** init_quelst ~~ 48.0
47: */
48:
49: int
50: init_quelst()
51: {
52: extern int neederr();
53: extern ack_err();
54: extern int Err_current;
55: extern int Patflag;
56: extern int Pars;
57: extern int Lcase;
58: extern int Dcase;
59: extern int Agflag;
60: extern int Opflag;
61: extern int Resrng;
62: extern int Qlflag;
63:
64: # ifdef xPTR3
65: tTfp(48, 0, "Init_quelst\n");
66: # endif
67:
68: Err_current = 0; /* no error yet */
69: Patflag = 0; /* reset pattern matching flag */
70: Pars = 1; /* set scanner into "parser" mode */
71: Lcase = Dcase; /* set case mapping to default */
72: Agflag = 0; /* reset aggregate flag */
73: Opflag = 0; /* reset qmode flag */
74: Resrng = -1; /* reset result relation slot */
75: Qlflag = 0; /* reset qualification flag */
76:
77: initp(); /* initialize parameter vector */
78: init_qt(); /* assume we have qrytree */
79:
80: freesym(); /* free symbol table space */
81: rngreset(); /* reset used bits in range tbl */
82:
83: return (1);
84: }
85:
86: /*
87: ** ENDQUELST -- finish command checking and processing for each quel statement
88: **
89: ** Parameters:
90: ** op -- the type of query to finish up
91: **
92: ** Returns:
93: ** nothing
94: **
95: ** Trace Flags:
96: ** endquelst ~~ 48.4, 48.5
97: */
98:
99: int
100: endquelst(op)
101: register int op;
102: {
103: register int i;
104: char ibuf[2]; /* two char buffer for index keys */
105:
106: extern char *Indexspec;
107: extern char *Indexname;
108: extern int Equel;
109: extern int Agflag;
110:
111: extern struct lasttok *Lasttok;
112:
113: extern int yyerrflag;
114: extern int Err_current;
115: extern int Ingerr;
116: extern int Err_fnd;
117:
118: extern DESC Attdes;
119: extern DESC Reldesc;
120: extern int Rsdmno;
121: extern PARRNG Parrng[];
122: extern int Resrng;
123:
124: extern int printtrail();
125:
126: # ifdef xPTR3
127: if (tTf(48, 4))
128: prvect(0, getp());
129: # endif
130:
131: /* check next token for GOVAL if the next token has been read */
132: if (!Err_current && !yyerrflag)
133: switch (op)
134: {
135: case mdSAVE:
136: case mdCOPY:
137: case mdCREATE:
138:
139: # ifdef DISTRIB
140: case mdDCREATE:
141: # endif
142:
143: case mdINDEX:
144: case mdRANGE:
145: break;
146:
147: default:
148: /* has vble ending and therefore must detect valid end of command */
149: # ifdef xPTR3
150: tTfp(48, 5, "before NXTCMDERR\n");
151: # endif
152: if (Lastok.tokop != GOVAL)
153: /* next token not start of command */
154: par_error(NXTCMDERR, WARN, 0);
155: break;
156: }
157:
158: if (Agflag >= MAXAGG)
159: /* too many aggregates */
160: par_error(AGGXTRA, WARN, 0);
161:
162: /* command ok so far, finish up */
163: if (!Err_fnd)
164: {
165: switch (op)
166: {
167: case mdINDEX:
168: if (tTf(48, 5))
169: printf("mdINDEX\n");
170: if (call(op, NULL) < 0)
171: ack_err();
172: if (tTf(48, 5))
173: printf("after call to call\n");
174:
175: if (Ingerr)
176: {
177: if (tTf(48, 5))
178: printf("Ingerr = %d\n", Ingerr);
179:
180: endgo();
181:
182: return (-1);
183: }
184:
185: if (Indexspec)
186: {
187: initp();
188: setp(PV_STR, Indexname); /* type */
189: setp(PV_STR, Indexspec); /* specs */
190: setp(PV_STR, "num");
191: for (i = 1; i <= Rsdmno; i++)
192: {
193: ibuf[0] = i & I1MASK;
194: ibuf[1] = '\0';
195: setp(PV_STR, ibuf);
196: }
197: if (call(mdMODIFY, NULL) < 0)
198: ack_err();
199: }
200: break;
201:
202: case mdRETR:
203: case mdRET_UNI:
204: case mdVIEW:
205: if (Resrng >= 0) /* implies result reln */
206: {
207: if (calln(mdCREATE, NULL) < 0)
208: ack_err();
209:
210: cleanrel(&Attdes);
211:
212: if ((i = openr(&Reldesc, -1, trim_relname(Parrng[Resrng].vardesc.reldum.relid))) < 0)
213: syserr("result reln: error in openr '%d'", i);
214:
215: rngent(R_INTERNAL, "", &Reldesc);
216: }
217: else if (!Equel)
218: /* need to print header */
219: header(getp());
220:
221: if (Ingerr)
222: {
223: /*
224: ** might be nice to back out the create already done
225: ** by this point so that the user doesn't need to
226: */
227: resetp();
228:
229: endgo(); /* abort rest of go-block */
230:
231: return (-1);
232: }
233: initp();
234: /* fall through */
235:
236: case mdAPP:
237: case mdDEL:
238: case mdREPL:
239: if (op != mdVIEW)
240: {
241: call_tree(op, mdQRY, ack_err);
242:
243: if (op == mdRETR || op == mdRET_UNI)
244: endretrieve(ack_err);
245:
246: break;
247: }
248:
249: # ifdef DISTRIB
250: case mdDISTRIB:
251: op = mdVIEW;
252: # endif
253: /* else, do VIEW */
254: setp(PV_STR, trim_relname(Parrng[Resrng].vardesc.reldum.relid));
255:
256: case mdINTEG:
257: case mdPROT:
258: call_tree(op, op, ack_err);
259: break;
260:
261: case mdCREATE:
262:
263: # ifdef DISTRIB
264: case mdDCREATE:
265: # endif
266:
267: case mdDESTROY:
268: case mdMODIFY:
269: # ifdef V6POINT3COMPAT
270: /* in this case, if an error in the dbu's will not */
271: /* cause other processing to halt */
272: call(op, NULL);
273: # else
274: if (call(op, NULL) < 0)
275: ack_err();
276: # endif
277: cleanrel(&Attdes);
278: break;
279:
280: case mdCOPY:
281: case mdHELP:
282: case mdPRINT:
283: case mdSAVE:
284: case mdDISPLAY:
285: case mdREMQM:
286: # ifdef V6POINT3COMPAT
287: call(op, NULL);
288: # else
289: if (call(op, NULL) < 0)
290: ack_err();
291: # endif
292: break;
293:
294: case mdRANGE:
295: break;
296:
297: default:
298: syserr("Endquelst: bad op %d", op);
299: }
300: }
301:
302: /* refresh relstat bits if necessary */
303: rngfresh(op);
304: if (init_quelst() < 0)
305: return (-1);
306:
307: return (1);
308: }
309:
310: /*
311: ** STARTGO -- do whatever needs doing to set up a go-block
312: **
313: ** Parameters:
314: ** none
315: **
316: ** Returns:
317: ** nothing
318: **
319: ** Trace Flags:
320: ** startgo ~~ 48.8
321: */
322:
323: startgo()
324: {
325: extern int Err_fnd;
326: extern int Ing_err;
327: extern int yyline;
328:
329: # ifdef xPTR3
330: tTfp(48, 8, "startgo\n");
331: # endif
332:
333: /* initialize for go-block */
334: get_scan(PRIME); /* prime the scanner input */
335: Err_fnd = 0; /* no errors have been found yet */
336: Ingerr = 0;
337:
338: if (init_quelst() < 0) /* most other init's are done for each statement */
339: return (-1);
340:
341: yyline = 1; /* reset line counter */
342:
343: return (1);
344: }
345:
346: /*
347: ** ENDGO -- do whatever needs doing to clean up after a go block
348: **
349: ** Parameters:
350: ** none
351: **
352: ** Returns:
353: ** nothing
354: **
355: ** Trace Flags:
356: ** endgo ~~ 48.12
357: */
358:
359: endgo()
360: {
361: # ifdef xPTR3
362: tTfp(48, 12, "endgo\n");
363: # endif
364:
365: if (!Equel && Err_fnd > 1)
366: error(SUMMARY, iocv(Err_fnd), 0);
367:
368: get_scan(SYNC);
369:
370: resetp();
371: }
372:
373: /*
374: ** ENDRETRIEVE -- finishes any sort of retrieve
375: **
376: ** Endretrieve either creates a result relation or prints a trailer
377: **
378: ** Parameters:
379: ** err_fcn -- function to pass to call
380: **
381: ** Returns:
382: ** nothing
383: **
384: ** Trace Flags:
385: ** endretrieve ~~ 48.14
386: **
387: ** History:
388: ** June '80 -- (jiw) broken off from call_tree
389: */
390:
391: endretrieve(err_fcn)
392: int (*err_fcn)();
393: {
394: extern int Resrng;
395: extern char *Relspec;
396: extern PARRNG Parrng[];
397: extern int Equel;
398:
399: if (Resrng >= 0)
400: {
401: if (Relspec)
402: {
403: initp();
404:
405: setp(PV_STR, trim_relname(Parrng[Resrng].vardesc.reldum.relid));
406: setp(PV_STR, Relspec);
407: if (call(mdMODIFY, err_fcn) < 0)
408: (*err_fcn)();
409: }
410: }
411: else if (!Equel)
412: printeh();
413: }
414:
415: printtrail()
416: {
417: extern int Equel;
418:
419: if (!Equel)
420: printeh();
421:
422: return (-1);
423: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.