![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to par_util.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / parser|
Return to par_util.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / parser |
1.1 root 1: # include <ingres.h>
2: # include <aux.h>
3: # include <tree.h>
4: # include "parser.h"
5: # include <catalog.h>
6: # include <pv.h>
7: # include <symbol.h>
8: # include <sccs.h>
9: # include "scanner.h"
10: # include <errors.h>
11:
12: SCCSID(@(#)par_util.c 8.2 2/14/85)
13:
14: /*
15: ** PAR_UTIL -- parser utility functions
16: **
17: ** These functions are generally unrelated except that they are
18: ** needed to operate the parser and are too small to be considered
19: ** seperate modules.
20: **
21: ** Defined Constants:
22: **
23: ** Defines:
24: ** timeofday -- convert arguments to minutes since midnight
25: ** tlprepend -- attach two target list components
26: ** header -- prints the header for a retrieve to terminal
27: ** patmat -- converts pattern matching characters in a string
28: ** permcom -- adds a command to the permit command vector
29: **
30: ** Requires:
31: ** nothing
32: **
33: ** Required By:
34: ** y.tab.c -- the grammar
35: **
36: ** Files:
37: ** none
38: **
39: ** Compilation Flags:
40: ** none
41: **
42: ** Trace Flags:
43: ** PAR_UTIL.C ~~ 62, 63
44: **
45: ** History:
46: ** 20 Dec 1978 -- written (rick)
47: */
48:
49:
50:
51:
52:
53:
54:
55:
56: /*
57: ** TIMEOFDAY -- convert 2 integers to minutes since midnight
58: **
59: ** Converts the hours and minutes parameters to minutes since midnight
60: ** performing some error (bounds) checking on the time.
61: **
62: ** To answer the question about what is midnight, both 0:00 and 24:00
63: ** are handled, but not the same way. The former is zero minutes from
64: ** midnight and the latter is 1440 minutes from midnight. (1440 is
65: ** 24 hrs times 60 minutes, or 1 minute past the end of the day.)
66: **
67: ** Parameters:
68: ** hrs -- an integer pointer to the hour
69: ** mins -- an integer pointer to the minutes
70: **
71: ** Returns:
72: ** integer time since midnight
73: **
74: ** Side Effects:
75: ** may detect an error and call par_error which never returns.
76: **
77: ** Requires:
78: ** that the pointers be on integer boundaries
79: **
80: ** Called By:
81: ** y.tab.c -- the grammar
82: **
83: ** Trace Flags:
84: ** none
85: **
86: ** Diagnostics:
87: ** BADHOURS -- No such hour
88: ** BADMINS -- No such minute
89: ** BAD24TIME -- only 24:00 allowed
90: **
91: ** Syserrs:
92: ** none
93: **
94: ** History:
95: ** 20 Dec 1978 -- written (rick)
96: */
97: timeofday(hrs, mins)
98: short *hrs;
99: short *mins;
100: {
101: register int h;
102: register int m;
103: register int rtval;
104:
105: h = *hrs;
106: m = *mins;
107: if (h > 24 || h < 0)
108: /* no such hour */
109: par_error(BADHOURS, WARN, iocv(h), 0);
110: if (m > 59 || m < 0)
111: /* no such minute */
112: par_error(BADMINS, WARN, iocv(m), 0);
113: if (h == 24)
114: {
115: h = 1440;
116: if (m != 0)
117: /* can only use 24:00 */
118: par_error(BAD24TIME, WARN, iocv(m), 0);
119: }
120: rtval = (h * 60) + m;
121: return (rtval);
122: }
123:
124:
125: /*
126: ** TLPREPEND -- combine two target list components
127: **
128: ** Attach two target list components to each other.
129: ** Neither component need be a single element. The
130: ** 'a' component will be attached at the extreme left
131: ** of the 'b' component.
132: **
133: ** Parameters:
134: ** a -- tl component to attach
135: ** b -- tl base for attaching
136: **
137: ** Returns:
138: ** nothing
139: **
140: ** Side Effects:
141: ** this routine is a side effect. It attaches a to b
142: ** and when it returns a is attached to b but the pointer
143: ** to b never changes (neither does the pointer to a)
144: **
145: ** Requires:
146: ** nothing
147: **
148: ** Called By:
149: ** y.tab.c -- the grammar
150: **
151: ** Trace Flags:
152: ** tlprepend ~~ 62.4
153: **
154: ** Diagnostics:
155: ** none
156: **
157: ** Syserrs:
158: ** none
159: **
160: ** History:
161: ** 20 Dec 1978 -- written (rick)
162: */
163:
164: QTREE *
165: tlprepend(a, b)
166: QTREE *a;
167: QTREE *b;
168: {
169: register QTREE *q;
170:
171: # ifdef xPTR1
172: tTfp(62, 4, "tlprepend\n");
173: # endif
174:
175: if (b==NULL)
176: return(a);
177: /* scan to the left end of b */
178: for (q = b; q->left != NULL; q = q->left)
179: ; /* no action */
180:
181: /* attach a to the end of b */
182: q->left = a;
183: return (b);
184: }
185:
186:
187:
188: /*
189: ** HEADER.C -- print header for retrieve to terminal
190: **
191: ** "setp" to reconstruct the field names and types and passing
192: ** them to the normal printhdr etc.
193: **
194: ** Defines:
195: ** header()
196: **
197: ** Requires:
198: ** printhdr - utility lib
199: ** beginhdr - utility lib
200: ** printeol - utility lib
201: ** printeh - utility lib
202: ** atoi - utility lib
203: ** Dc - vble, number of params in list
204: ** Dv - vble, list of parameters
205: **
206: ** Trace Flags:
207: ** none
208: **
209: ** History:
210: ** written (ancient history) (rick)
211: */
212: header(pv)
213: PARM *pv;
214: {
215: int len;
216: HDRINFO *hptr;
217: HDRINFO *tptr;
218: int start = 1;
219: extern HDRINFO *Hdrptr;
220: extern HDRINFO *Fieldwidth;
221: extern int Hdr;
222:
223: Hdr = TRUE;
224: beginhdr();
225:
226:
227: for (; pv->pv_type != PV_EOF; pv += 2)
228: {
229: if ((pv[1].pv_val.pv_str[0] & I1MASK) == 'c')
230: {
231: tptr = (HDRINFO *) malloc(sizeof(HDRINFO));
232: if (start)
233: {
234: Hdrptr = tptr;
235: Fieldwidth = Hdrptr;
236: start = 0;
237: }
238: else
239: hptr->next = tptr;
240: hptr = tptr;
241: }
242:
243: len = atoi(&pv[1].pv_val.pv_str[1]);
244: printhdr(pv[1].pv_val.pv_str[0] & I1MASK, len, pv->pv_val.pv_str);
245:
246: if ((pv[1].pv_val.pv_str[0] & I1MASK) == 'c')
247: {
248: tptr->len = len;
249: tptr->len &= 0377;
250: tptr->next = NULL;
251: }
252: }
253: printeol();
254: printeh();
255: }
256:
257:
258:
259:
260:
261:
262: /*
263: ** PATMAT -- converts pattern matching characters in a string
264: **
265: ** Searches a string up to a null byte for one of the pattern
266: ** matching characters '*', '?', '[', and ']'. It then converts
267: ** these characters to their internal control character equivalents.
268: **
269: ** Parameters:
270: ** str -- the string to search
271: **
272: ** Returns:
273: ** 0 -- always
274: **
275: ** Side Effects:
276: ** none
277: **
278: ** Requires:
279: ** symbol.h
280: **
281: ** Called By:
282: ** y.tab.c -- grammar
283: **
284: ** Trace Flags:
285: ** none
286: **
287: ** Diagnostics:
288: ** none
289: **
290: ** Syserrs:
291: ** none
292: **
293: ** History:
294: ** written (ancient history) (rick)
295: ** amended (Heidi) -- checks for numbers after PAT_SPEC's
296: ** and does away with flags making pattern matching
297: ** characters legal in strings
298: */
299:
300:
301: /*
302: ** PATMAT
303: ** hunts through a string and converts the pattern matching
304: ** characters and replaces with the corresponding cntrl chars
305: */
306: patmat(str)
307: char *str;
308: {
309: register int i; /* index variables */
310: register char *p, *q, c;
311: extern int Qlflag;
312:
313: q = str;
314: for (p = str; *p; p++)
315: {
316: if (*p == '\\')
317: {
318: *q++ = *++p;
319: continue;
320: }
321: switch (*p)
322: {
323: case '#':
324: if (*(p + 1) == '#')
325: {
326: p++;
327: if ((c = *(p + 1)) == '0')
328: {
329: *q++ = PAT_GLOB;
330: p++;
331: }
332: else if (c >= '1' && c <= '9')
333: {
334: if ( !Qlflag ) /* target*/
335: Patspec_flag[c - '0'] = 1;
336: else /* qualifier */
337: {
338: if( Patspec_flag[c - '0'] == (TARGBIT | QUALBIT))
339: {
340: for (i=0; i<PATNUM; i++)
341: Patspec_flag[i] = 0;
342: par_error(DUPINDEX,WARN,0);
343: }
344: /* allows for repeated indices in
345: ** qualifier as long as index is not
346: ** mentioned in target
347: */
348: else
349: Patspec_flag[c - '0'] = Patspec_flag[c - '0'] | QUALBIT;
350: }
351: *q++ = PAT_SPEC;
352: }
353: else
354: par_error(NOINDEX,WARN,0);
355: continue;
356: }
357: else
358: *q++ = *p;
359: continue;
360:
361: case '*':
362: if (!Qlflag)
363: par_error(NOPATMAT, WARN, 0);
364: *q++ = PAT_ANY;
365: continue;
366:
367: case '?':
368: if (!Qlflag)
369: par_error(NOPATMAT, WARN, 0);
370: *q++ = PAT_ONE;
371: continue;
372:
373: case '[':
374: if (!Qlflag)
375: par_error(NOPATMAT, WARN, 0);
376: *q++ = PAT_LBRAC;
377: continue;
378:
379: case ']':
380: if (!Qlflag)
381: par_error(NOPATMAT, WARN, 0);
382: *q++ = PAT_RBRAC;
383: continue;
384:
385: default:
386: *q++ = *p;
387: continue;
388: }
389: }
390: *q = '\0';
391: return (0);
392: }
393: /*
394: ** PERMCOM -- map command allowed into protection catalog bits
395: **
396: ** translates the QMODE type symbols into the appropriate counterparts
397: ** for the permit statement allowed command vector. The manifest
398: ** constants are designed to be inclusive or'd together to form a
399: ** composite bit map of OK actions.
400: **
401: ** Parameters:
402: ** a -- the QMODE type symbol for the command to add
403: **
404: ** Returns:
405: ** none
406: **
407: ** Side Effects:
408: ** changes the variable Permcomd to reflect the additional permission
409: **
410: ** Requires:
411: ** Permcomd must be define globally
412: ** catalog.h for the proper constants
413: **
414: ** Called By:
415: ** y.tab.c -- the grammar
416: **
417: ** Trace Flags:
418: ** none
419: **
420: ** Diagnostics:
421: ** none
422: **
423: ** Syserrs:
424: ** bad QMODE(%d) -- a bad symbol has been passed for mapping
425: **
426: ** History:
427: ** 28 Dec 1978 -- written (rick)
428: */
429:
430: permcom(a)
431: int a;
432: {
433: extern int Permcomd;
434: switch (a)
435: {
436: case mdRETR:
437: Permcomd |= PRO_RETR;
438: break;
439:
440: case mdAPP:
441: Permcomd |= PRO_APP;
442: break;
443:
444: case mdREPL:
445: Permcomd |= PRO_REPL;
446: break;
447:
448: case mdDEL:
449: Permcomd |= PRO_DEL;
450: break;
451:
452: case -1:
453: Permcomd |= 0177777; /* all bits set */
454: break;
455:
456: default:
457: syserr("permcom: bad QMODE(%d)", a);
458: }
459: }
460:
461: char *
462: makestr(str)
463: register char *str;
464: {
465: register char *result;
466: register int len;
467:
468: len = length(str) + 1;
469:
470: result = (char *) need(Qbuf, len);
471:
472: bmove(str, result, len);
473:
474: return (result);
475: }
476:
477:
478: /*
479: ** QUALINDEX --
480: ** check to see if a PAT_SPEC index was used in a target
481: ** list and not in a qualifier list
482: **
483: ** Returns: 0 if ok
484: ** calls par_error if not ok
485: **
486: ** Called by: y.tab.c -grammar
487: */
488:
489: qualindex()
490: {
491: int i;
492:
493: for (i=0; i<PATNUM; i++)
494: {
495: if (Patspec_flag[i] == TARGBIT)
496: {
497: /* reset the rest of the flag array */
498: while (i++ < PATNUM)
499: Patspec_flag[i] = 0;
500: par_error(NOQUALINDX, WARN, 0);
501: }
502: Patspec_flag[i] = 0;
503: }
504: return(0);
505: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.