![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to readqry.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 / ctlmod|
Return to readqry.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / ctlmod |
1.1 root 1: # include "ctlmod.h"
2: # include <ingres.h>
3: # include <aux.h>
4: # include <tree.h>
5: # include <symbol.h>
6: # include <sccs.h>
7:
8: SCCSID(@(#)readqry.c 7.1 2/5/81)
9:
10: # define STACKFULL 3701 /* trbuild stack ovflo error */
11:
12: /*
13: ** READQRY
14: **
15: ** Reads in query symbols from input pipe into core
16: ** locations and sets up information needed for later
17: ** processing.
18: **
19: ** Returns ptr to root of querytree
20: **
21: ** Locbuf is a 'struct srcid' since that is the largest node of
22: ** a QMODE, SOURCEID, or RESULTVAR node.
23: */
24:
25: QTREE *
26: readqry(rdfn, fnparam, initialize)
27: int (*rdfn)(); /* tree read function */
28: int fnparam; /* parameter to pass to rdfn */
29: bool initialize; /* if set, initialize Qbuf */
30: {
31: register QTREE *q;
32: register QTREE *rtval;
33: register DESC *d;
34: extern QTREE *readtree();
35: extern char *xalloc();
36: extern QTREE *trbuild();
37: int mark;
38: extern QTREE *readsym();
39: int i;
40: int j;
41:
42: # ifdef xCTR1
43: if (tTf(10, 8))
44: printf("READQRY:\n");
45: # endif
46:
47: if (initialize)
48: {
49: /* initialize for new query block */
50: clrrange();
51: Qt.qt_resvar = -1;
52: Qt.qt_qmode = -1;
53: }
54: for (i = 0; i < MAXRANGE; i++)
55: Qt.qt_remap[i] = i;
56:
57: mark = markbuf(Qbuf);
58:
59: /* read symbols from input */
60: for (;;)
61: {
62: freebuf(Qbuf, mark);
63: q = readsym(rdfn, fnparam);
64: switch (q->sym.type)
65: {
66: case QMODE:
67: if (Qt.qt_qmode != -1)
68: syserr("readqry: two qmodes");
69: Qt.qt_qmode = q->sym.value.sym_data.i2type;
70: break;
71:
72: case RESULTVAR:
73: if (Qt.qt_resvar != -1)
74: syserr("readqry: two resultvars");
75: Qt.qt_resvar = q->sym.value.sym_data.i2type;
76: break;
77:
78: case SOURCEID:
79: d = (DESC *) xalloc(sizeof *d);
80: bmove((char *) &q->sym.value.sym_srcid.srcdesc, (char *) d, sizeof *d);
81: i = q->sym.value.sym_srcid.srcvar;
82: j = declare(i, d);
83: if (j != i && initialize)
84: syserr("readqry: declare(%d)=%d", i, j);
85: Qt.qt_remap[i] = j;
86: break;
87:
88: case TREE: /* beginning of tree, no more other stuff */
89: q = readtree(q, rdfn, fnparam);
90: rtval = trbuild(q);
91: if (rtval == NULL)
92: error(STACKFULL, 0);
93: return (rtval);
94:
95: default:
96: syserr("readqry: bad symbol %d", q->sym.type);
97: }
98: }
99: }
100: /*
101: ** READSYM
102: ** reads in one symbol from pipe into symbol struct.
103: */
104:
105: QTREE *
106: readsym(rdfn, fnparam)
107: int (*rdfn)(); /* tree read function */
108: char *fnparam;
109: {
110: register int len;
111: register int t;
112: register QTREE *q;
113: extern char *need();
114: int rlen;
115:
116: q = (QTREE *) need(Qbuf, QT_HDR_SIZ);
117: if ((*rdfn)(fnparam, &q->sym, TYP_LEN_SIZ) < TYP_LEN_SIZ)
118: syserr("readsym: read sym");
119: rlen = len = q->sym.len & I1MASK;
120: t = q->sym.type;
121:
122: switch (t)
123: {
124: case AND:
125: if (len < 6)
126: len = 6;
127: break;
128:
129: case ROOT:
130: case AGHEAD:
131: if (len < 8)
132: len = 8;
133: break;
134: }
135:
136: q->sym.len = len;
137:
138:
139: if (len != 0)
140: {
141: /* this will be contiguous with above need call */
142: need(Qbuf, len);
143: }
144: if (rlen != 0)
145: {
146: if ((*rdfn)(fnparam, &q->sym.value, rlen) < rlen)
147: syserr("readsym: read val (sym=%d,%d)", t, rlen);
148: }
149:
150: switch (t)
151: {
152: case ROOT:
153: q->sym.value.sym_root.rootuser = TRUE;
154: break;
155: case AGHEAD:
156: q->sym.value.sym_root.rootuser = FALSE;
157: break;
158: }
159: # ifdef xCTR1
160: if (tTf(10, 9))
161: nodepr(q);
162: # endif xCTR1
163:
164: return (q);
165: }
166: /*
167: ** READTREE
168: **
169: ** reads in tree symbols into a buffer up to a root (end) symbol
170: **
171: */
172:
173: QTREE *
174: readtree(tresym, rdfn, fnparam)
175: QTREE *tresym;
176: int (*rdfn)();
177: char *fnparam;
178: {
179: register QTREE *q;
180: register QTREE *rtval;
181: extern char *need();
182:
183: rtval = tresym;
184:
185: for(;;)
186: {
187: /* space for left & right pointers */
188: q = readsym(rdfn, fnparam);
189: if (q->sym.type == ROOT)
190: return (rtval);
191: }
192: }
193: /*
194: ** TRBUILD -- Rebuild a tree in memory
195: **
196: ** Trbuild is called with a pointer to the TREE node of
197: ** a query already in memory. It rebuilds the pointer
198: ** structure assuming the querytree is in postfix order.
199: **
200: ** Parameters:
201: ** bufptr - a pointer to the TREE node
202: **
203: ** Returns:
204: ** NULL - Internal stack overflow (STACKSIZ)
205: ** pointer to the ROOT node
206: **
207: ** Side Effects:
208: ** All left & right pointers are rebuilt.
209: **
210: ** Called By:
211: ** readqry
212: **
213: ** Syserrs:
214: ** syserr if there are too many leaf nodes or too
215: ** few child nodes
216: */
217:
218:
219: QTREE *
220: trbuild(bufptr)
221: QTREE *bufptr;
222: {
223: register QTREE **stackptr;
224: register char *p;
225: register SYMBOL *s;
226: QTREE *treestack[STACKSIZ];
227: extern bool leaf();
228:
229:
230: stackptr = treestack;
231:
232: for (p = (char *) bufptr;; p += QT_HDR_SIZ + ((s->len + 1) & 0376))
233: {
234: s = &((QTREE *)p)->sym;
235: ((QTREE *)p)->left = ((QTREE *)p)->right = 0;
236:
237: /* reunite p with left and right children on stack, if any*/
238: if (!leaf((QTREE *) p)) /* this node has children */
239: {
240: if (s->type != UOP)
241: if (stackptr <= treestack)
242: {
243: err:
244: syserr("trbuild:too few nodes");
245: }
246: else
247: ((QTREE *)p)->right = *(--stackptr);
248: if (s->type != AOP)
249: if (stackptr <= treestack)
250: goto err;
251: else
252: ((QTREE *)p)->left = *(--stackptr);
253: }
254:
255: /*
256: ** If this is a ROOT node then the tree is complete.
257: ** verify that there are no extra nodes in the
258: ** treestack.
259: */
260: if (s->type == ROOT) /* root node */
261: {
262: if (stackptr != treestack)
263: syserr("trbuild:xtra nodes");
264: return ((QTREE *)p);
265: }
266:
267: /* stack p */
268: if (stackptr-treestack >= STACKSIZ)
269: return (NULL); /* error:stack full */
270: *(stackptr++) = (QTREE *) p;
271:
272: }
273: }
274:
275:
276: bool
277: leaf(p)
278: QTREE *p;
279: {
280: switch (p->sym.type)
281: {
282: case VAR:
283: case TREE:
284: case QLEND:
285: case INT:
286: case FLOAT:
287: case CHAR:
288: case COP:
289: return(TRUE);
290:
291: default:
292: return(FALSE);
293: }
294: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.