![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to help.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 / dbu|
Return to help.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu |
1.1 root 1: # include <pv.h>
2: # include <ingres.h>
3: # include <aux.h>
4: # include <catalog.h>
5: # include <access.h>
6: # include <func.h>
7: # include <signal.h>
8: # include <sccs.h>
9: # include <errors.h>
10:
11: SCCSID(@(#)help.c 8.5 2/8/85)
12:
13: extern short tTdbu[100];
14: extern int help();
15: extern int null_fn();
16:
17: struct fn_def HelpFn =
18: {
19: "HELP",
20: help,
21: null_fn, /* initialization function */
22: null_fn,
23: NULL,
24: 0,
25: tTdbu,
26: 100,
27: 'Z',
28: 0
29: };
30:
31:
32: /*
33: ** HELP - Provide Information to User
34: **
35: ** Arguments:
36: ** pv[i] - code
37: ** RELINFO - print relation information
38: ** MANSEC - print manual section
39: ** DELIMLIST - print delim information
40: ** RELIST - print relation list
41: ** ALLRELINFO - print relation info for all accessible
42: ** relations
43: **
44: ** pv[i+1] - name of entity for modes 0 or 1
45: **
46: ** Trace Flags:
47: ** 44
48: */
49:
50: help(parmc, parmv)
51: int parmc;
52: PARM parmv[];
53: {
54: DESC des;
55: int mode;
56: register PARM *pv;
57: register int ret;
58: int i;
59:
60: # ifdef xZTR1
61: if (tTf(44, -1))
62: {
63: printf(">>help\n");
64: if (tTf(44, 0))
65: prvect(parmc, parmv);
66: }
67: # endif
68:
69: ret = 0;
70: pv = parmv;
71: getuser(-1); /* init getuser for modes RELINFO & MANSEC */
72: while (pv->pv_type != PV_EOF)
73: {
74: mode = (pv++)->pv_val.pv_int;
75: if (mode < RELIST && pv->pv_type == PV_EOF)
76: syserr("help: mode %d no val", mode);
77:
78: # ifdef xZTR1
79: if (tTf(44, -1))
80: {
81: printf("help %d", mode);
82: if (mode != RELIST)
83: printf(" %s", pv->pv_val.pv_str);
84: putchar('\n');
85: }
86: # endif
87: switch (mode)
88: {
89:
90: case RELINFO: /* help relation */
91: if (!openr(&des, OR_RELTID, pv->pv_val.pv_str))
92: {
93: rel_fmt(&des);
94: pv->pv_val.pv_str = NULL;
95: }
96: pv++;
97: break;
98:
99: case MANSEC: /* help manual section */
100: if (man(pv->pv_val.pv_str))
101: pv->pv_val.pv_str = NULL;
102: pv++;
103: break;
104:
105: case DELLIST: /* help delim */
106: if (!openr(&des, OR_READ, "rdelim"))
107: {
108: if ((i = helpdelim(pv->pv_val.pv_str,&des)) == -1)
109: return(error(RDELIMERR, pv->pv_val.pv_str, 0));
110: closer(&des);
111: pv->pv_val.pv_str = NULL;
112: }
113: pv++;
114: break;
115:
116: case RELIST:
117: case ALLRELINFO:
118: relpr(mode);
119: break;
120:
121: case ALLDELLIST:
122: if (!openr(&des, OR_READ, "rdelim"))
123: {
124: if ((i = alldelims(&des)) == -1)
125: return(error(RDELIMERR, pv->pv_val.pv_str, 0));
126: closer(&des);
127: pv->pv_val.pv_str = NULL;
128: }
129: pv++;
130: break;
131:
132: default:
133: syserr("HELP: mode %d", mode);
134: }
135: }
136: getuser(0); /* close getuser in case mode RELINFO or MANSEC */
137:
138: /* now rescan for error messages */
139: pv = parmv;
140: while (pv->pv_type != PV_EOF)
141: {
142: mode = (pv++)->pv_val.pv_int;
143:
144: if (mode < RELIST)
145: {
146: if (pv->pv_val.pv_str != NULL)
147: ret = nferror(NORELEXIST + mode, pv->pv_val.pv_str, 0);
148: pv++;
149: }
150: }
151: return (ret);
152: }
153:
154:
155: /*
156: ** Nroff Manual Section
157: **
158: ** The manual section given by 'name' is nroff'ed. Returns one
159: ** on success, zero if the manual section is not found.
160: **
161: ** Uses trace flag 11
162: */
163:
164: int
165: man(name)
166: char *name;
167: {
168: char manual[100];
169: register int i;
170: int stat;
171: char name_nr[18];
172: register char *naa;
173: extern char *ztack();
174:
175: if (length(name) > 14)
176: return (0);
177:
178: /* a null manual name gives table of contents */
179: if (name[0] == 0)
180: smove("../toc.nr", name_nr);
181: else
182: concat(name, ".nr", name_nr);
183:
184: concat(ztack(Pathname, "/doc/quel/"), name_nr, manual);
185: if ((i = open(manual, O_RDONLY)) < 0)
186: {
187: /* try a unix command instead */
188: concat(ztack(Pathname, "/doc/unix/"), name_nr, manual);
189: if ((i = open(manual, O_RDONLY)) < 0)
190: return (0);
191: }
192: if (close(i))
193: syserr("cannot close %s", manual);
194: ruboff(0); /* wait for child's death if rubout occures */
195: i = fork();
196: if (i == 0)
197: {
198: signal(SIGINT, SIG_DFL); /* die on rubout */
199: setuid(getuid());
200: # ifndef xB_UNIX
201: setgid(getgid());
202: # endif
203: naa = ztack(Pathname, "/doc/iaa");
204: execl("/bin/nroff", "nroff", naa, manual, 0);
205: execl("/usr/bin/nroff", "nroff", naa, manual, 0);
206: syserr("help: exec: nroff");
207: }
208: /* wait for nroff if fork succeeded */
209: if (i > 0)
210: fullwait(i, "help: nroff");
211: rubon();
212: return (1);
213: }
214:
215:
216: /*
217: ** PRINT DATABASE INFORMATION
218: **
219: ** Prints a list of all the relations in the database, together
220: ** with their owner.
221: **
222: ** Uses trace flag 12
223: */
224:
225: relpr(mode)
226: int mode;
227: {
228: extern DESC Reldes;
229: register DESC *d;
230: register int i;
231: register char *cp;
232: struct tup_id limtid, tid;
233: char buf[MAXLINE + 1];
234: char lastuser[2];
235: struct relation rel;
236:
237: opencatalog("relation", OR_READ);
238: d = &Reldes;
239: if (i = find(d, NOKEY, &tid, &limtid))
240: syserr("help: relpr: find %d", i);
241:
242: lastuser[0] = '\0';
243:
244: if (mode == RELIST)
245: printf("\n relation name relation owner\n\n");
246:
247: while ((i = get(d, &tid, &limtid, &rel, 1)) == 0)
248: {
249: if (mode == RELIST)
250: {
251: if (!bequal(lastuser, rel.relowner, 2))
252: {
253: if (getuser(rel.relowner, buf))
254: {
255: /* cant find user code */
256: bmove(" ", buf, 2);
257: cp = &buf[2];
258: bmove(rel.relowner, cp, 2);
259: cp = &cp[2];
260: *cp = '\0';
261: }
262: else
263: {
264: for (cp = buf; *cp != ':'; cp++)
265: ;
266: *cp = '\0';
267: }
268: bmove(rel.relowner, lastuser, 2);
269: }
270: printf(" %.12s %s\n", rel.relid, buf);
271: }
272: else
273: {
274: if ((rel.relstat & S_CATALOG) || bequal("_SYS", rel.relid, 4))
275: continue;
276: if (bequal(Usercode, rel.relowner, UCODE_SZ) || bequal(Admin.adhdr.adowner, rel.relowner, 2))
277: rel_fmt(&rel);
278: }
279: }
280:
281: if (i < 0)
282: syserr("help: relpr: get %d", i);
283: if (mode == RELIST)
284: printf("\n");
285: return (0);
286: }
287:
288:
289:
290: /*
291: ** Print Relation Information
292: **
293: ** Prints detailed information regarding the relation.
294: **
295: ** Uses trace flag 13
296: */
297:
298: rel_fmt(r)
299: register struct relation *r;
300: {
301: struct tup_id limtid, tid;
302: char buf[MAXLINE + 1];
303: struct attribute att;
304: struct index indkey, ind;
305: register int i;
306: int j;
307: extern DESC Attdes, Inddes;
308: char *trim_relname();
309:
310: printf("\nRelation:\t\t%s\n", trim_relname(r->relid));
311: i = getuser(r->relowner, buf);
312: if (i)
313: {
314: smove("(xx)", buf);
315: bmove(r->relowner, &buf[1], 2);
316: }
317: else
318: {
319: for (i = 0; buf[i] != ':'; i++)
320: continue;
321: buf[i] = 0;
322: }
323: printf("Owner:\t\t\t%s\n", buf);
324: printf("Tuple width:\t\t%d\n", r->relwid);
325: if (r->relsave != 0)
326: {
327: printf("Saved until:\t\t%s", ctime(&r->relsave));
328: }
329: if ((r->relstat & S_VIEW) == 0)
330: {
331: printf("Number of tuples:\t%ld\n", r->reltups);
332: printf("Storage structure:\t");
333: i = r->relspec;
334: if (i < 0)
335: {
336: printf("compressed ");
337: i = -i;
338: }
339: switch (i)
340: {
341:
342: case M_HEAP:
343: printf("paged heap\n");
344: break;
345:
346: case M_ISAM:
347: printf("ISAM file\n");
348: break;
349:
350: case M_HASH:
351: printf("random hash\n");
352: break;
353:
354: default:
355: printf("unknown structure %d\n", i);
356: break;
357:
358: }
359: }
360:
361: printf("Relation type:\t\t");
362: if (r->relstat & S_CATALOG)
363: printf("system catalog\n");
364: else if (r->relstat & S_VIEW)
365: printf("view\n");
366: else
367: if (r->reldim > 0)
368: printf("ordered relation\n");
369: else if (r->relindxd < 0)
370: {
371: printf("secondary index on ");
372: opencatalog("indexes", OR_READ);
373: setkey(&Inddes, &indkey, r->relowner, IOWNERP);
374: setkey(&Inddes, &indkey, r->relid, IRELIDI);
375: if (!getequal(&Inddes, &indkey, &ind, &tid))
376: printf("%s\n", trim_relname(ind.irelidp));
377: else
378: printf("unknown relation\n");
379: }
380: else
381: {
382: if (r->relstat & S_DISTRIBUTED)
383: printf("distributed ");
384: printf("user relation\n");
385: }
386: if (r->relindxd > 0)
387: {
388: printf("Secondary Indices:\t");
389: opencatalog("indexes", OR_READ);
390: setkey(&Inddes, &indkey, r->relid, IRELIDP);
391: setkey(&Inddes, &indkey, r->relowner, IOWNERP);
392: if (i = find(&Inddes, EXACTKEY, &tid, &limtid, &indkey))
393: syserr("help: find %d indexes", i);
394: j = FALSE;
395: while ((i = get(&Inddes, &tid, &limtid, &ind, 1)) == 0)
396: {
397: if (!bequal(&indkey, &ind, MAXNAME + 2))
398: continue;
399: if (j)
400: printf(", ");
401: j =TRUE;
402: printf("%s", trim_relname(ind.irelidi));
403: }
404: if (i < 0)
405: syserr("help:get indexes %d", i);
406: if (!j)
407: printf("unknown");
408: }
409: printf("\n");
410:
411: opencatalog("attribute", OR_READ);
412: printf("\n attribute name type length keyno.\n\n");
413: seq_init(&Attdes, r);
414: while (seq_attributes(&Attdes, r, &att))
415: {
416: printf(" %.12s %c%8d",
417: att.attname, att.attfrmt, att.attfrml & I1MASK);
418: if (att.attxtra)
419: printf("%7d", att.attxtra);
420: printf("\n");
421: }
422:
423: printf("\n");
424: return (0);
425: }
426:
427: /*
428: ** HELPDELIM - print all delims presently defined.
429: **
430: ** Parameters:
431: ** group - the group of delims to print
432: **
433: ** Returns:
434: ** 0 - if successful
435: ** -1 - if relation not found
436: */
437: helpdelim(group,des)
438: char *group;
439: DESC *des;
440: {
441: DELIM_TUP tuple;
442: TID lotid,hitid;
443: int notfound = 1;
444: char delim[12];
445: int start = 0;
446: int begin = 1;
447: char dstring[1024];
448: char *dptr;
449: int found=0;
450:
451: if (find(des,LRANGEKEY, &lotid, &hitid, group) < 0)
452: return(-1);
453: find(des,HRANGEKEY, &lotid, &hitid, group);
454: printf("\n \t>>>> %s <<<<\n", group);
455:
456: while (!get(des, &lotid, &hitid, &tuple, 1))
457: {
458:
459: if (strcmp(tuple.group, group))
460: continue;
461:
462: if (strcmp(tuple.delim, delim))
463: start = 1;
464:
465: if (start)
466: {
467: found = 1;
468: if (begin)
469: begin = 0;
470: else
471: print_delim(dstring);
472:
473: /*start a new string*/
474: strcpy(delim, tuple.delim);
475: start = 0;
476: *dstring = NULL;
477: strcat(dstring, tuple.delim);
478: strcat(dstring, ": ");
479: convert_bitmap(dstring, &tuple);
480: }
481: else
482: {
483: /*add to old string*/
484: convert_bitmap(dstring, &tuple);
485: }
486: }
487: if (!found)
488: printf("group %s does not exist\n", group);
489: else
490: print_delim(dstring);
491: return(0);
492: }
493:
494: /*
495: ** CONVERT_BITMAP - convert a bitmap back to a BNF expression
496: **
497: ** Parameters:
498: ** dstring - string to stuff the BNF expression info
499: ** tuple - tuple containing the bitmap
500: **
501: */
502: convert_bitmap(dstring, tuple)
503: char *dstring;
504: DELIM_TUP *tuple;
505: {
506: int i,j;
507: char *pntr;
508:
509: pntr = dstring + strlen(dstring);
510: *pntr++ = (tuple->type == ONE ? LBRACKET : LBRACE);
511: i = 0;
512: while (i < 128 )
513: {
514: if (test(tuple->bitmap, i))
515: {
516: *pntr++ = i;
517: j = ++i;
518: while ((j < 128) && test(tuple->bitmap, j))
519: j++;
520: if ( (j - i) >= 5)
521: {
522: j--;
523: *pntr++ = '-';
524: *pntr++ = j;
525: i = j + 1;
526: }
527: }
528: else
529: i++;
530: }
531: *pntr++ = (tuple->type == ONE ? RBRACKET : RBRACE);
532: *pntr = NULL;
533: }
534:
535: /*
536: ** PRINT_DELIM - print one delim of the rdelim relation
537: **
538: ** Parameters:
539: **
540: */
541: print_delim(delim)
542: char *delim;
543: {
544: printf("%s\n", delim);
545: }
546:
547: /*
548: ** ALLDELIMS - print all the delims currently defined
549: **
550: */
551: alldelims(des)
552: DESC *des;
553: {
554: DELIM_TUP tuple;
555: int start=1;
556: char group[12];
557: TID lotid;
558: TID hitid;
559:
560: printf("Delimitor groups:\n");
561: if (find(des,LRANGEKEY, &lotid, &hitid, group) < 0)
562: return(-1);
563: find(des,HRANGEKEY, &lotid, &hitid, group);
564:
565: while (!get(des, &lotid, &hitid, &tuple, 1))
566: {
567:
568: if (strcmp(tuple.group, group))
569: start = 1;
570:
571: if (start)
572: {
573: strcpy(group, tuple.group);
574: printf("\t\t %s\n", group);
575: /*helpdelim(group, des); */
576: start = 0;
577: }
578: }
579: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.