![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to att_fcn.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 att_fcn.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 <symbol.h>
5: # include "parser.h"
6: # include <sccs.h>
7:
8: SCCSID(@(#)att_fcn.c 7.1 2/5/81)
9:
10: /*
11: ** fake attribute stash entries for tid nodes (and sid in dist version)
12: ** these are provided by the system to a program only for debugging
13: ** the system source and do not have well defined (over time) meanings.
14: */
15: struct atstash Faketid =
16: {
17: 0, INT, 4, "tid", 0
18: };
19: #ifdef DISTRIB
20: struct atstash Fakesid
21: {
22: 0, INT, 4, "sid", 0
23: };
24: #endif
25:
26: struct atstash Attable[MAXATT];/* attrib stash space, turned into a list later */
27: struct atstash *Freeatt; /* free list of attrib stash */
28:
29: /*
30: ** ATT_FCN.C -- attribute list manipulation routines
31: **
32: ** ATT_FCN ~~ trace flags = 40, 41
33: **
34: ** Defines:
35: ** Attable
36: ** Freeatt
37: ** attinit()
38: ** attlookup()
39: ** attadd()
40: ** attfnd()
41: ** attcheck()
42: ** attfree()
43: ** attalloc()
44: ** attcount()
45: **
46: ** History:
47: ** modified for 6.3 (jiw)
48: */
49:
50: /*
51: ** ATTINIT -- initializes attribute table
52: **
53: ** Parameters:
54: ** none
55: **
56: ** Trace Flags:
57: ** attinit ~~ 40.0
58: */
59:
60: attinit()
61: {
62: register struct atstash *atptr;
63: register int i;
64:
65: # ifdef xPTR3
66: tTfp(40, 0, "attinit");
67: # endif
68:
69: atptr = Attable;
70:
71: for (i = 0; i < MAXATT - 1; i++)
72: {
73: atptr->atbnext = atptr + 1;
74: atptr++;
75: }
76:
77: atptr->atbnext = NULL;
78:
79: Freeatt = Attable; /* the first attribute in chain */
80: }
81:
82: /*
83: ** ATTLOOKUP -- finds attribute entry
84: **
85: ** Attlookup looks up atribute 'attrib' in the att stash
86: ** for range table entry 'slot'. If the attrib is not
87: ** in the stash it is entered.
88: **
89: ** Parameters:
90: ** attrib -- the name of the attribute to find
91: ** slot -- the number of the range variable
92: **
93: ** Returns:
94: ** pointer to the attstash element
95: **
96: ** Trace Flags:
97: ** attlookup ~~ 40.4, 40.5
98: */
99:
100: struct atstash *
101: attlookup(slot, attrib)
102: int slot;
103: char *attrib;
104: {
105: register PARRNG *rptr;
106: register struct atstash *current;
107: int ik;
108: struct attribute tuple;
109: register struct attribute *ktuple;
110: struct attribute ktup;
111: TID tid;
112:
113: extern struct atstash *attfind();
114: extern struct atstash *attadd();
115: extern DESC Attdes;
116: extern PARRNG Parrng[];
117:
118: rptr = &Parrng[slot];
119:
120: ktuple = &ktup;
121: # ifdef xPTR2
122: tTfp(40, 4, "attlookup: att = %s and rel= %s\n", attrib, trim_relname(rptr->vardesc.reldum.relid));
123: # endif
124:
125: /* attribute called "tid" is phantom attribute, use fake */
126: if (sequal("tid", attrib))
127: return (&Faketid);
128: # ifdef DISTRIB
129: if (sequal("sid", attrib))
130: return (&Fakesid);
131: # endif
132:
133: /* check to see if attrib is in stash */
134: if ((current = attfind(slot, attrib)) != NULL)
135: return (current);
136:
137: # ifdef xPTR2
138: tTfp(40, 5, "getting att info from relation\n");
139: # endif
140:
141: /* rel name, owner, attname is unique ident */
142: clearkeys(&Attdes);
143: setkey(&Attdes, ktuple, rptr->vardesc.reldum.relid, ATTRELID);
144: setkey(&Attdes, ktuple, rptr->vardesc.reldum.relowner, ATTOWNER);
145: setkey(&Attdes, ktuple, attrib, ATTNAME);
146: if (!(ik = getequal(&Attdes, ktuple, &tuple, &tid)))
147: {
148: /* put attrib stuff into att stash */
149: current = attadd(slot, &tuple);
150: return (current);
151: }
152:
153: if (ik == 1)
154: /* attribute not in relation */
155: par_error(NOATTRIN, WARN, attrib, trim_relname(rptr->vardesc.reldum.relid), 0);
156: else
157: syserr("fatal error in getequal, ret: %d", ik);
158: }
159:
160: /*
161: ** ATTADD -- add an attribute to the list for a particular range variable
162: **
163: ** Parameters:
164: ** slot -- the number of the range variable to use
165: ** tuple -- the attribute tuple to add
166: **
167: ** Returns:
168: ** pointer to the attribute added
169: **
170: ** Trace Flags:
171: ** attadd ~~ 40.8
172: */
173:
174: struct atstash *
175: attadd(slot, tuple)
176: int slot;
177: struct attribute *tuple;
178: {
179: register struct atstash *current;
180: register struct atstash *aptr;
181: register struct atstash *bptr;
182: PARRNG *rptr;
183: int i;
184:
185: extern struct atstash *attalloc();
186: extern PARRNG Parrng[];
187:
188: # ifdef xPTR3
189: tTfp(40, 8, "attadd slot %d, %12s\n", slot, tuple->attname);
190: # endif
191:
192: rptr = &Parrng[slot];
193:
194: current = attalloc();
195: current->atbid = tuple->attid;
196: current->atbfrmt = tuple->attfrmt;
197: current->atbfrml = tuple->attfrml;
198: bmove(tuple->attname, current->atbname, MAXNAME);
199: for (i = 0; i < MAXNAME; i++)
200: if (current->atbname[i] == ' ')
201: current->atbname[i] = '\0';
202:
203: aptr = rptr->attlist;
204: bptr = 0;
205: while (aptr != 0)
206: {
207: if (aptr->atbid > current->atbid)
208: break;
209: bptr = aptr;
210: aptr = aptr->atbnext;
211: }
212: if (bptr == 0)
213: rptr->attlist = current;
214: else
215: bptr->atbnext = current;
216:
217: current->atbnext = aptr;
218:
219: return (current);
220: }
221:
222: /*
223: ** ATTFIND -- finds attribute in stash
224: **
225: ** Attfind looks in attribute stash to see if attrib info already there
226: ** return pointer to attribute in attribute table else NULL.
227: **
228: ** Parameters:
229: ** slot -- the number of the entry in range table
230: ** attrib -- the attribute name to find
231: **
232: ** Returns:
233: ** pointer to entry or NULL if not in stash
234: **
235: ** Trace Flags:
236: ** attfind ~~ 40.12
237: */
238:
239: struct atstash *
240: attfind(slot, attrib)
241: int slot;
242: register char *attrib;
243: {
244: register struct atstash *aptr;
245:
246: extern PARRNG Parrng[];
247:
248: # ifdef xPTR1
249: tTfp(40, 12, "attadd\n");
250: # endif
251:
252: aptr = Parrng[slot].attlist;
253:
254: while (aptr != NULL)
255: {
256: if (!scompare(attrib, MAXNAME, aptr->atbname, MAXNAME))
257: return (aptr);
258:
259: aptr = aptr->atbnext;
260: }
261: return (NULL);
262: }
263:
264: /*
265: ** ATTCHECK -- checks for conflicts in attributes
266: **
267: ** Attcheck checks for type conflicts in the current query domain and
268: ** attable entry
269: **
270: ** Parameters:
271: ** aptr -- pointer to current atttibute
272: **
273: ** Returns:
274: ** nothing
275: **
276: ** Requires:
277: ** Trfrmt -- for current format
278: **
279: ** Trace Flags:
280: ** attcheck ~~ 41.0
281: */
282:
283: attcheck(aptr)
284: register struct atstash *aptr;
285: {
286: extern char Trfrmt;
287:
288: # ifdef xPTR1
289: tTfp(41, 0, "attcheck\n");
290: # endif
291:
292: if ((Trfrmt == CHAR) != (aptr->atbfrmt == CHAR))
293: /* function type does not match attrib */
294: par_error(RESTYPE, WARN, aptr->atbname, 0);
295: }
296:
297: /*
298: ** ATTFREE -- puts a list of attrib space back on the free list
299: **
300: ** Parameters:
301: ** aptr -- pointer to list of attstash entries
302: **
303: ** Returns:
304: ** nothing
305: **
306: ** Requires:
307: ** Freeatt
308: **
309: ** Trace Flags:
310: ** attfree ~~ 41.4
311: */
312:
313: attfree(aptr)
314: struct atstash *aptr;
315: {
316: register struct atstash *att;
317:
318: # ifdef xPTR1
319: tTfp(41, 4, "attfree\n");
320: # endif
321:
322: if ((att = aptr) == NULL)
323: return;
324:
325: while (att->atbnext != NULL)
326: att = att->atbnext;
327:
328: att->atbnext = Freeatt;
329: Freeatt = aptr;
330: }
331:
332: /*
333: ** ATTALLOC -- returns a pointer to a atstash type structure
334: **
335: ** Attalloc checks the freelist (Freeatt) for attstash entries,
336: ** if some is there, one is removed. If the freelist is empty,
337: ** attstashes are removed from range table entries until an free
338: ** element is found.
339: **
340: ** Parameters:
341: ** none
342: **
343: ** Returns:
344: ** a pointer to an atstash element
345: **
346: ** Requires:
347: ** Rngback
348: ** Freeatt
349: **
350: ** Trace Flags:
351: ** attalloc ~~ 41.8, 41.9
352: */
353:
354: struct atstash *
355: attalloc()
356: {
357: register struct atstash *aptr;
358: register PARRNG *rptr;
359:
360: extern PARRNG *Rngback;
361:
362: # ifdef xPTR3
363: tTfp(41, 8, "attalloc Freeatt %d\n", Freeatt);
364: # endif
365:
366: /* Note: the following loop doesn't happen if Freeatt != NULL */
367:
368: for (rptr = Rngback; Freeatt == NULL; rptr = rptr->frontpt)
369: {
370: /*
371: ** search least recently used vbles for attrib stash space
372: ** until at least one entry is found
373: */
374:
375: # ifdef xPTR3
376: tTfp(41, 9, "attalloc: freeing %12s\n", rptr->vardesc.relvname);
377: # endif
378:
379: if (rptr == NULL)
380: syserr("attalloc: no att space.");
381:
382: Freeatt = rptr->attlist;
383: rptr->attlist = NULL;
384: }
385: aptr = Freeatt;
386: Freeatt = Freeatt->atbnext;
387: aptr->atbnext = NULL;
388:
389: return (aptr);
390: }
391:
392: /*
393: ** ATTCOUNT -- counts atstash elems
394: **
395: ** Attcount returns a count fof the number of attributes already in the
396: ** attrib stash.
397: **
398: ** Parameter:
399: ** slot -- the range table entry to count
400: **
401: ** Returns:
402: ** count of the attributes
403: **
404: ** Trace Flags:
405: ** attcount ~~ 41.12
406: */
407:
408: int
409: attcount(slot)
410: int slot;
411: {
412: register int cntr;
413: register struct atstash *aptr;
414:
415: extern PARRNG Parrng[];
416:
417: # ifdef xPTR1
418: tTfp(41, 12, "attcount\n");
419: # endif
420:
421: cntr = 0;
422: aptr = Parrng[slot].attlist;
423: while (aptr != NULL)
424: {
425: cntr++;
426: aptr = aptr->atbnext;
427: }
428: return (cntr);
429: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.