![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfontedpr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / vgrind|
Return to vfontedpr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / vgrind |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)vfontedpr.c 5.1 (Berkeley) 6/5/85";
9: #endif not lint
10:
11: #include <ctype.h>
12: #include <stdio.h>
13: #include <sys/types.h>
14: #include <sys/stat.h>
15:
16: #define boolean int
17: #define TRUE 1
18: #define FALSE 0
19: #define NIL 0
20: #define STANDARD 0
21: #define ALTERNATE 1
22:
23: /*
24: * Vfontedpr.
25: *
26: * Dave Presotto 1/12/81 (adapted from an earlier version by Bill Joy)
27: *
28: */
29:
30: #define STRLEN 10 /* length of strings introducing things */
31: #define PNAMELEN 40 /* length of a function/procedure name */
32: #define PSMAX 20 /* size of procedure name stacking */
33:
34: /* regular expression routines */
35:
36: char *expmatch(); /* match a string to an expression */
37: char *STRNCMP(); /* a different kindof strncmp */
38: char *convexp(); /* convert expression to internal form */
39: char *tgetstr();
40:
41: boolean isproc();
42:
43:
44: char *ctime();
45:
46: /*
47: * The state variables
48: */
49:
50: boolean incomm; /* in a comment of the primary type */
51: boolean instr; /* in a string constant */
52: boolean inchr; /* in a string constant */
53: boolean nokeyw = FALSE; /* no keywords being flagged */
54: boolean index = FALSE; /* form an index */
55: boolean filter = FALSE; /* act as a filter (like eqn) */
56: boolean pass = FALSE; /* when acting as a filter, pass indicates
57: * whether we are currently processing
58: * input.
59: */
60: boolean prccont; /* continue last procedure */
61: int comtype; /* type of comment */
62: int margin;
63: int psptr; /* the stack index of the current procedure */
64: char pstack[PSMAX][PNAMELEN+1]; /* the procedure name stack */
65: int plstack[PSMAX]; /* the procedure nesting level stack */
66: int blklevel; /* current nesting level */
67: char *defsfile = "/usr/lib/vgrindefs"; /* name of language definitions file */
68: char pname[BUFSIZ+1];
69:
70: /*
71: * The language specific globals
72: */
73:
74: char *language = "c"; /* the language indicator */
75: char *l_keywds[BUFSIZ/2]; /* keyword table address */
76: char *l_prcbeg; /* regular expr for procedure begin */
77: char *l_combeg; /* string introducing a comment */
78: char *l_comend; /* string ending a comment */
79: char *l_acmbeg; /* string introducing a comment */
80: char *l_acmend; /* string ending a comment */
81: char *l_blkbeg; /* string begining of a block */
82: char *l_blkend; /* string ending a block */
83: char *l_strbeg; /* delimiter for string constant */
84: char *l_strend; /* delimiter for string constant */
85: char *l_chrbeg; /* delimiter for character constant */
86: char *l_chrend; /* delimiter for character constant */
87: char l_escape; /* character used to escape characters */
88: boolean l_toplex; /* procedures only defined at top lex level */
89:
90: /*
91: * global variables also used by expmatch
92: */
93: boolean _escaped; /* if last character was an escape */
94: char *_start; /* start of the current string */
95: boolean l_onecase; /* upper and lower case are equivalent */
96:
97: #define ps(x) printf("%s", x)
98:
99: main(argc, argv)
100: int argc;
101: char *argv[];
102: {
103: int lineno;
104: char *fname = "";
105: char *ptr;
106: struct stat stbuf;
107: char buf[BUFSIZ];
108: char strings[2 * BUFSIZ];
109: char defs[2 * BUFSIZ];
110: int needbp = 0;
111:
112: argc--, argv++;
113: do {
114: char *cp;
115: int i;
116:
117: if (argc > 0) {
118: if (!strcmp(argv[0], "-h")) {
119: if (argc == 1) {
120: printf("'ds =H\n");
121: argc = 0;
122: goto rest;
123: }
124: printf("'ds =H %s\n", argv[1]);
125: argc--, argv++;
126: argc--, argv++;
127: if (argc > 0)
128: continue;
129: goto rest;
130: }
131:
132: /* act as a filter like eqn */
133: if (!strcmp(argv[0], "-f")) {
134: filter++;
135: argv[0] = argv[argc-1];
136: argv[argc-1] = "-";
137: continue;
138: }
139:
140: /* take input from the standard place */
141: if (!strcmp(argv[0], "-")) {
142: argc = 0;
143: goto rest;
144: }
145:
146: /* build an index */
147: if (!strcmp(argv[0], "-x")) {
148: index++;
149: argv[0] = "-n";
150: }
151:
152: /* indicate no keywords */
153: if (!strcmp(argv[0], "-n")) {
154: nokeyw++;
155: argc--, argv++;
156: continue;
157: }
158:
159: /* specify the font size */
160: if (!strncmp(argv[0], "-s", 2)) {
161: i = 0;
162: cp = argv[0] + 2;
163: while (*cp)
164: i = i * 10 + (*cp++ - '0');
165: printf("'ps %d\n'vs %d\n", i, i+1);
166: argc--, argv++;
167: continue;
168: }
169:
170: /* specify the language */
171: if (!strncmp(argv[0], "-l", 2)) {
172: language = argv[0]+2;
173: argc--, argv++;
174: continue;
175: }
176:
177: /* specify the language description file */
178: if (!strncmp(argv[0], "-d", 2)) {
179: defsfile = argv[1];
180: argc--, argv++;
181: argc--, argv++;
182: continue;
183: }
184:
185: /* open the file for input */
186: if (freopen(argv[0], "r", stdin) == NULL) {
187: perror(argv[0]);
188: exit(1);
189: }
190: if (index)
191: printf("'ta 4i 4.25i 5.5iR\n'in .5i\n");
192: fname = argv[0];
193: argc--, argv++;
194: }
195: rest:
196:
197: /*
198: * get the language definition from the defs file
199: */
200: i = tgetent (defs, language, defsfile);
201: if (i == 0) {
202: fprintf (stderr, "no entry for language %s\n", language);
203: exit (0);
204: } else if (i < 0) {
205: fprintf (stderr, "cannot find vgrindefs file %s\n", defsfile);
206: exit (0);
207: }
208: cp = strings;
209: if (tgetstr ("kw", &cp) == NIL)
210: nokeyw = TRUE;
211: else {
212: char **cpp;
213:
214: cpp = l_keywds;
215: cp = strings;
216: while (*cp) {
217: while (*cp == ' ' || *cp =='\t')
218: *cp++ = NULL;
219: if (*cp)
220: *cpp++ = cp;
221: while (*cp != ' ' && *cp != '\t' && *cp)
222: cp++;
223: }
224: *cpp = NIL;
225: }
226: cp = buf;
227: l_prcbeg = convexp (tgetstr ("pb", &cp));
228: cp = buf;
229: l_combeg = convexp (tgetstr ("cb", &cp));
230: cp = buf;
231: l_comend = convexp (tgetstr ("ce", &cp));
232: cp = buf;
233: l_acmbeg = convexp (tgetstr ("ab", &cp));
234: cp = buf;
235: l_acmend = convexp (tgetstr ("ae", &cp));
236: cp = buf;
237: l_strbeg = convexp (tgetstr ("sb", &cp));
238: cp = buf;
239: l_strend = convexp (tgetstr ("se", &cp));
240: cp = buf;
241: l_blkbeg = convexp (tgetstr ("bb", &cp));
242: cp = buf;
243: l_blkend = convexp (tgetstr ("be", &cp));
244: cp = buf;
245: l_chrbeg = convexp (tgetstr ("lb", &cp));
246: cp = buf;
247: l_chrend = convexp (tgetstr ("le", &cp));
248: l_escape = '\\';
249: l_onecase = tgetflag ("oc");
250: l_toplex = tgetflag ("tl");
251:
252: /* initialize the program */
253:
254: incomm = FALSE;
255: instr = FALSE;
256: inchr = FALSE;
257: _escaped = FALSE;
258: blklevel = 0;
259: for (psptr=0; psptr<PSMAX; psptr++) {
260: pstack[psptr][0] = NULL;
261: plstack[psptr] = 0;
262: }
263: psptr = -1;
264: ps("'-F\n");
265: if (!filter) {
266: printf(".ds =F %s\n", fname);
267: fstat(fileno(stdin), &stbuf);
268: cp = ctime(&stbuf.st_mtime);
269: cp[16] = '\0';
270: cp[24] = '\0';
271: printf(".ds =M %s %s\n", cp+4, cp+20);
272: ps("'wh 0 vH\n");
273: ps("'wh -1i vF\n");
274: }
275: if (needbp) {
276: needbp = 0;
277: printf(".()\n");
278: printf(".bp\n");
279: }
280:
281: /*
282: * MAIN LOOP!!!
283: */
284: while (fgets(buf, sizeof buf, stdin) != NULL) {
285: if (buf[0] == '\f') {
286: printf(".bp\n");
287: }
288: if (buf[0] == '.') {
289: printf("%s", buf);
290: if (!strncmp (buf+1, "vS", 2))
291: pass = TRUE;
292: if (!strncmp (buf+1, "vE", 2))
293: pass = FALSE;
294: continue;
295: }
296: prccont = FALSE;
297: if (!filter || pass)
298: putScp(buf);
299: else
300: printf("%s", buf);
301: if (prccont && (psptr >= 0)) {
302: ps("'FC ");
303: ps(pstack[psptr]);
304: ps("\n");
305: }
306: #ifdef DEBUG
307: printf ("com %o str %o chr %o ptr %d\n", incomm, instr, inchr, psptr);
308: #endif
309: margin = 0;
310: }
311: needbp = 1;
312: } while (argc > 0);
313: exit(0);
314: }
315:
316: #define isidchr(c) (isalnum(c) || (c) == '_')
317:
318: putScp(os)
319: char *os;
320: {
321: register char *s = os; /* pointer to unmatched string */
322: char dummy[BUFSIZ]; /* dummy to be used by expmatch */
323: char *comptr; /* end of a comment delimiter */
324: char *acmptr; /* end of a comment delimiter */
325: char *strptr; /* end of a string delimiter */
326: char *chrptr; /* end of a character const delimiter */
327: char *blksptr; /* end of a lexical block start */
328: char *blkeptr; /* end of a lexical block end */
329:
330: _start = os; /* remember the start for expmatch */
331: _escaped = FALSE;
332: if (nokeyw || incomm || instr)
333: goto skip;
334: if (isproc(s)) {
335: ps("'FN ");
336: ps(pname);
337: ps("\n");
338: if (psptr < PSMAX) {
339: ++psptr;
340: strncpy (pstack[psptr], pname, PNAMELEN);
341: pstack[psptr][PNAMELEN] = NULL;
342: plstack[psptr] = blklevel;
343: }
344: }
345: skip:
346: do {
347: /* check for string, comment, blockstart, etc */
348: if (!incomm && !instr && !inchr) {
349:
350: blkeptr = expmatch (s, l_blkend, dummy);
351: blksptr = expmatch (s, l_blkbeg, dummy);
352: comptr = expmatch (s, l_combeg, dummy);
353: acmptr = expmatch (s, l_acmbeg, dummy);
354: strptr = expmatch (s, l_strbeg, dummy);
355: chrptr = expmatch (s, l_chrbeg, dummy);
356:
357: /* start of a comment? */
358: if (comptr != NIL)
359: if ((comptr < strptr || strptr == NIL)
360: && (comptr < acmptr || acmptr == NIL)
361: && (comptr < chrptr || chrptr == NIL)
362: && (comptr < blksptr || blksptr == NIL)
363: && (comptr < blkeptr || blkeptr == NIL)) {
364: putKcp (s, comptr-1, FALSE);
365: s = comptr;
366: incomm = TRUE;
367: comtype = STANDARD;
368: if (s != os)
369: ps ("\\c");
370: ps ("\\c\n'+C\n");
371: continue;
372: }
373:
374: /* start of a comment? */
375: if (acmptr != NIL)
376: if ((acmptr < strptr || strptr == NIL)
377: && (acmptr < chrptr || chrptr == NIL)
378: && (acmptr < blksptr || blksptr == NIL)
379: && (acmptr < blkeptr || blkeptr == NIL)) {
380: putKcp (s, acmptr-1, FALSE);
381: s = acmptr;
382: incomm = TRUE;
383: comtype = ALTERNATE;
384: if (s != os)
385: ps ("\\c");
386: ps ("\\c\n'+C\n");
387: continue;
388: }
389:
390: /* start of a string? */
391: if (strptr != NIL)
392: if ((strptr < chrptr || chrptr == NIL)
393: && (strptr < blksptr || blksptr == NIL)
394: && (strptr < blkeptr || blkeptr == NIL)) {
395: putKcp (s, strptr-1, FALSE);
396: s = strptr;
397: instr = TRUE;
398: continue;
399: }
400:
401: /* start of a character string? */
402: if (chrptr != NIL)
403: if ((chrptr < blksptr || blksptr == NIL)
404: && (chrptr < blkeptr || blkeptr == NIL)) {
405: putKcp (s, chrptr-1, FALSE);
406: s = chrptr;
407: inchr = TRUE;
408: continue;
409: }
410:
411: /* end of a lexical block */
412: if (blkeptr != NIL) {
413: if (blkeptr < blksptr || blksptr == NIL) {
414: putKcp (s, blkeptr - 1, FALSE);
415: s = blkeptr;
416: blklevel--;
417: if (psptr >= 0 && plstack[psptr] >= blklevel) {
418:
419: /* end of current procedure */
420: if (s != os)
421: ps ("\\c");
422: ps ("\\c\n'-F\n");
423: blklevel = plstack[psptr];
424:
425: /* see if we should print the last proc name */
426: if (--psptr >= 0)
427: prccont = TRUE;
428: else
429: psptr = -1;
430: }
431: continue;
432: }
433: }
434:
435: /* start of a lexical block */
436: if (blksptr != NIL) {
437: putKcp (s, blksptr - 1, FALSE);
438: s = blksptr;
439: blklevel++;
440: continue;
441: }
442:
443: /* check for end of comment */
444: } else if (incomm) {
445: comptr = expmatch (s, l_comend, dummy);
446: acmptr = expmatch (s, l_acmend, dummy);
447: if (((comtype == STANDARD) && (comptr != NIL)) ||
448: ((comtype == ALTERNATE) && (acmptr != NIL))) {
449: if (comtype == STANDARD) {
450: putKcp (s, comptr-1, TRUE);
451: s = comptr;
452: } else {
453: putKcp (s, acmptr-1, TRUE);
454: s = acmptr;
455: }
456: incomm = FALSE;
457: ps("\\c\n'-C\n");
458: continue;
459: } else {
460: putKcp (s, s + strlen(s) -1, TRUE);
461: s = s + strlen(s);
462: continue;
463: }
464:
465: /* check for end of string */
466: } else if (instr) {
467: if ((strptr = expmatch (s, l_strend, dummy)) != NIL) {
468: putKcp (s, strptr-1, TRUE);
469: s = strptr;
470: instr = FALSE;
471: continue;
472: } else {
473: putKcp (s, s+strlen(s)-1, TRUE);
474: s = s + strlen(s);
475: continue;
476: }
477:
478: /* check for end of character string */
479: } else if (inchr) {
480: if ((chrptr = expmatch (s, l_chrend, dummy)) != NIL) {
481: putKcp (s, chrptr-1, TRUE);
482: s = chrptr;
483: inchr = FALSE;
484: continue;
485: } else {
486: putKcp (s, s+strlen(s)-1, TRUE);
487: s = s + strlen(s);
488: continue;
489: }
490: }
491:
492: /* print out the line */
493: putKcp (s, s + strlen(s) -1, FALSE);
494: s = s + strlen(s);
495: } while (*s);
496: }
497:
498: putKcp (start, end, force)
499: char *start; /* start of string to write */
500: char *end; /* end of string to write */
501: boolean force; /* true if we should force nokeyw */
502: {
503: int i;
504: int xfld = 0;
505:
506: while (start <= end) {
507: if (index) {
508: if (*start == ' ' || *start == '\t') {
509: if (xfld == 0)
510: printf("&");
511: printf("\t");
512: xfld = 1;
513: while (*start == ' ' || *start == '\t')
514: start++;
515: continue;
516: }
517: }
518:
519: /* take care of nice tab stops */
520: if (*start == '\t') {
521: while (*start == '\t')
522: start++;
523: i = tabs(_start, start) - margin / 8;
524: printf("\\h'|%dn'", i * 10 + 1 - margin % 8);
525: continue;
526: }
527:
528: if (!nokeyw && !force)
529: if ((*start == '#' || isidchr(*start))
530: && (start == _start || !isidchr(start[-1]))) {
531: i = iskw(start);
532: if (i > 0) {
533: ps("\\*(+K");
534: do
535: putcp(*start++);
536: while (--i > 0);
537: ps("\\*(-K");
538: continue;
539: }
540: }
541:
542: putcp (*start++);
543: }
544: }
545:
546:
547: tabs(s, os)
548: char *s, *os;
549: {
550:
551: return (width(s, os) / 8);
552: }
553:
554: width(s, os)
555: register char *s, *os;
556: {
557: register int i = 0;
558:
559: while (s < os) {
560: if (*s == '\t') {
561: i = (i + 8) &~ 7;
562: s++;
563: continue;
564: }
565: if (*s < ' ')
566: i += 2;
567: else
568: i++;
569: s++;
570: }
571: return (i);
572: }
573:
574: putcp(c)
575: register int c;
576: {
577:
578: switch(c) {
579:
580: case 0:
581: break;
582:
583: case '\f':
584: break;
585:
586: case '{':
587: ps("\\*(+K{\\*(-K");
588: break;
589:
590: case '}':
591: ps("\\*(+K}\\*(-K");
592: break;
593:
594: case '\\':
595: ps("\\e");
596: break;
597:
598: case '_':
599: ps("\\*_");
600: break;
601:
602: case '-':
603: ps("\\*-");
604: break;
605:
606: case '`':
607: ps("\\`");
608: break;
609:
610: case '\'':
611: ps("\\'");
612: break;
613:
614: case '.':
615: ps("\\&.");
616: break;
617:
618: case '*':
619: ps("\\fI*\\fP");
620: break;
621:
622: case '/':
623: ps("\\fI\\h'\\w' 'u-\\w'/'u'/\\fP");
624: break;
625:
626: default:
627: if (c < 040)
628: putchar('^'), c |= '@';
629: case '\t':
630: case '\n':
631: putchar(c);
632: }
633: }
634:
635: /*
636: * look for a process beginning on this line
637: */
638: boolean
639: isproc(s)
640: char *s;
641: {
642: pname[0] = NULL;
643: if (!l_toplex || blklevel == 0)
644: if (expmatch (s, l_prcbeg, pname) != NIL) {
645: return (TRUE);
646: }
647: return (FALSE);
648: }
649:
650:
651: /* iskw - check to see if the next word is a keyword
652: */
653:
654: iskw(s)
655: register char *s;
656: {
657: register char **ss = l_keywds;
658: register int i = 1;
659: register char *cp = s;
660:
661: while (++cp, isidchr(*cp))
662: i++;
663: while (cp = *ss++)
664: if (!STRNCMP(s,cp,i) && !isidchr(cp[i]))
665: return (i);
666: return (0);
667: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.