![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree.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 tree.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 <tree.h>
4: # include <pv.h>
5: # include "parser.h"
6: # include <symbol.h>
7: # include <sccs.h>
8:
9: SCCSID(@(#)tree.c 7.1 2/5/81)
10:
11:
12: /*
13: ** TREE
14: ** FUNCTION TO ADD NODE TO QUERY TREE
15: ** RETURN VALUE IS POINTER TO NODE JUST CREATED
16: */
17: QTREE *
18: tree(lptr, rptr, typ, len, valu, attnum)
19: QTREE *lptr;
20: QTREE *rptr;
21: char typ;
22: int len;
23: register int valu;
24: register struct atstash *attnum;
25: {
26: register QTREE *tptr;
27: extern char Trfrmt;
28: extern char Trfrml;
29: extern char *need();
30: extern QTREE *norm();
31: extern int Err_current;
32:
33: # ifdef xPTR3
34: tTfp(55, 0, "tree type(%d), len(%d), value(%d).\n", typ, len, valu);
35: # endif
36:
37: if (Err_current)
38: return (NULL);
39:
40: /* Following is a hack. Sorry about that John. */
41: if (typ == AND)
42: len = sizeof (struct rootnode) - sizeof (short);
43:
44: tptr = (QTREE *) need(Qbuf, QT_HDR_SIZ + len);
45: tptr->left = lptr;
46: tptr->right = rptr;
47: tptr->sym.type = typ;
48: tptr->sym.len = len;
49:
50: switch (typ)
51: {
52: case VAR:
53: tptr->sym.value.sym_var.varno = valu & I1MASK;
54: tptr->sym.value.sym_var.attno = attnum->atbid;
55: tptr->sym.value.sym_var.varfrmt = attnum->atbfrmt;
56: tptr->sym.value.sym_var.varfrml = attnum->atbfrml;
57: tptr->sym.value.sym_var.valptr = NULL;
58: break;
59:
60: case ROOT:
61: case AGHEAD:
62: tptr->sym.value.sym_root.rootuser = valu;
63: break;
64:
65: case TREE:
66: case BYHEAD:
67: case AND:
68: case OR:
69: case QLEND:
70: break;
71:
72: case UOP:
73: case BOP:
74: tptr->sym.value.sym_op.opno = valu;
75: format(tptr);
76: break;
77:
78: case COP:
79: if ((tptr->sym.value.sym_op.opno = getcop(valu)) == BADCOP)
80: {
81: /* bad const operator */
82: par_error(BADCONSTOP, WARN, valu, 0);
83: return(NULL);
84: }
85: break;
86:
87: case AOP:
88: format(tptr->right);
89: tptr->sym.value.sym_op.agfrmt = Trfrmt;
90: tptr->sym.value.sym_op.agfrml = Trfrml;
91:
92: case RESDOM:
93: tptr->sym.value.sym_resdom.resno = valu;
94: format(tptr);
95: tptr->sym.value.sym_resdom.resfrmt = Trfrmt;
96: tptr->sym.value.sym_resdom.resfrml = Trfrml;
97: break;
98:
99: default:
100: /* INT, FLOAT, CHAR */
101: bmove(valu, &tptr->sym.value, len & I1MASK);
102: break;
103: }
104: return (tptr);
105: }
106:
107: /*
108: ** WINDUP
109: ** assign resno's to resdoms of an agg fcn
110: */
111: windup(ptr)
112: QTREE *ptr;
113: {
114: register int tot;
115: register int kk;
116: register QTREE *t;
117:
118: /* COUNT THE RESDOM'S OF THIS TARGET LIST */
119: kk = 1;
120: for (t = ptr; t; t = t->left)
121: kk++;
122: tot = 1;
123: for (t=ptr; t;t = t->left)
124: t->sym.value.sym_resdom.resno = kk - tot++;
125: }
126:
127: /*
128: ** ADDRESDOM - makes a new entry for the target list
129: **
130: ** Trname must contain the name of the resdom to
131: ** use for the header, create and Rsdmno for append, replace
132: **
133: ** the parameters are pointers to the subtrees to be
134: ** suspended from the node
135: */
136: QTREE *
137: addresdom(lptr, rptr)
138: QTREE *lptr, *rptr;
139: {
140: register QTREE *rtval;
141: register struct atstash *aptr;
142: char buf[10]; /* buffer type and length in ascii for dbu */
143:
144: extern int Opflag;
145: extern int Rsdmno;
146: extern int Equel;
147: extern int Resrng;
148: extern char Trfrmt;
149: extern char Trfrml;
150: extern char *Trname;
151: extern PARRNG Parrng[];
152:
153: extern QTREE *tree();
154: extern struct atstash *attlookup();
155:
156: int temp;
157:
158: switch (Opflag)
159: {
160: case mdRETR:
161: case mdRET_UNI:
162: case mdVIEW:
163: Rsdmno++;
164: if (Rsdmno >= MAXDOM)
165: /* too many resdoms */
166: par_error(RESXTRA, FATAL, 0);
167: rtval = tree(lptr, rptr, RESDOM, sizeof (struct resdomnode), Rsdmno);
168: if (!Equel || Resrng)
169: {
170: /* buffer info for header or CREATE */
171: setp(PV_STR, Trname);
172:
173: buf[0] = Trfrmt & I1MASK;
174: smove(iocv(Trfrml & I1MASK), &buf[1]);
175:
176: setp(PV_STR, buf);
177: }
178: break;
179:
180: default:
181: /*
182: ** for append and replace, the result domain
183: ** number is determined by the location of
184: ** the attribute in the result relation
185: */
186: if (sequal(Trname, "tid"))
187: /* attrib not found */
188: par_error(NOATTRIN, WARN, Trname,
189: trim_relname(Parrng[Resrng].vardesc.reldum.relid), 0);
190: # ifdef DISTRIB
191: if (sequal(Trname, "sid"))
192: /* attrib not found */
193: par_error(NOATTRIN, WARN, Trname,
194: trim_relname(Parrng[Resrng].vardesc.reldum.relid), 0);
195: # endif
196: aptr = attlookup(Resrng, Trname);
197: Rsdmno = aptr->atbid;
198: rtval = tree(lptr, rptr, RESDOM, sizeof (struct resdomnode), Rsdmno);
199: if (Opflag != mdPROT) /* INTEGRITY not possible here */
200: attcheck(aptr);
201: break;
202: }
203: return (rtval);
204: }
205: /*
206: ** GETCOP
207: ** routine to lookup 'string' in constant operators table
208: ** constant table is declared in tables.y
209: ** structure is defined in ../parser.h
210: */
211: getcop(string)
212: char *string;
213: {
214: register struct constop *cpt;
215: register char *sptr;
216: extern struct constop Coptab[];
217:
218: sptr = string;
219: for (cpt = Coptab; cpt->copname; cpt++)
220: if (sequal(sptr, cpt->copname))
221: return (cpt->copnum);
222: return (BADCOP);
223: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.