[unix-history] / usr / src / cmd / pxp / yycomm.c

/* Copyright (c) 1979 Regents of the University of California */
#
/*
 * pxp - Pascal execution profiler
 *
 * Bill Joy UCB
 * Version 1.2 January 1979
 */

#include "0.h"
#include "yy.h"

/*
 * COMMENT PROCESSING CLUSTER
 *
 * The global organization of this cluster is as follows.
 * While parsing the program information is saved in the tree which
 * tells the source text coordinates (sequence numbers and columns)
 * bounding each production.  The comments from the source program
 * are also saved, with information about their source text position
 * and a classification as to their kind.
 *
 * When printing the reformatted program we flush out the comments
 * at various points using the information in the comments and the parse
 * tree to "resynchronize".  A number of special cases are recognized to
 * deal with the vagarities of producing a true "fixed point" so that
 * a prettyprinted program will re-prettyprint to itself.
 */

/*
 * Save sequence id's and column markers bounding a production
 * for later use in placing comments.  We save the sequence id
 * and column of the leftmost token and the following token, and
 * the sequence id of the last token in this reduction.
 * See putcm, putcml, and putcmp below for motivation.
 */
line2of(l)
	int l;
{

	return (lineNof(l, 2));
}

lineof(l)
	int l;
{

	return (lineNof(l, 1));
}

lineNof(l, i)
	int l, i;
{

	return(tree(6, l, yypw[i].Wseqid, yypw[i].Wcol, yyseqid, yycol, yypw[N].Wseqid));
}

/*
 * After a call to setline, Seqid is set to the sequence id
 * of the symbol which followed the reduction in which the
 * lineof call was embedded, Col to the associated column,
 * and LSeqid to the sequence id of the last symbol in the reduction
 * (Note that this is exact only if the last symbol was a terminal
 * this is always true when it matters.)
 */
int	Seqid, Col, LSeqid;

/*
 * Retrieve the information from a call to lineof before beginning the
 * output of a tree from a reduction.  First flush to the left margin
 * of the production, and then set so that later calls to putcm, putcml
 * and putcmp will deal with the right margin of this comment.
 *
 * The routine setinfo is called when the lineof has no embedded line
 * number to avoid trashing the current "line".
 *
 * The routine setinfo is often called after completing the output of
 * the text of a tree to restore Seqid, Col, and LSeqid which may have
 * been destroyed by the nested processing calls to setline.
 * In this case the only effect of the call to setinfo is to
 * modify the above three variables as a side effect.
 *
 * We return a word giving information about the comments which were
 * actually put out.  See putcm for details.
 */
setline(ip)
	int *ip;
{

	line = ip[0];
	return(setinfo(ip));
}

setinfo(ip)
	register int *ip;
{
	register int i;

	ip++;
	Seqid = *ip++;
	Col = *ip++;
	i = putcm();
	Seqid = *ip++;
	Col = *ip++;
	LSeqid = *ip++;
	return (i);
}

char	cmeof, incomm;

/*
 * Get the text of a comment from the input stream,
 * recording its type and linking it into the linked
 * list of comments headed by cmhp.
 */
getcm(cmdelim)
	char cmdelim;
{
	int cmjust, col;
	register struct comment *cp;
	register struct commline *kp;

	incomm = 1;
	if (cmdelim == '*' && yycol == 10 || cmdelim == '{' && yycol == 9)
		cmjust = CLMARG;
	else if (yytokcnt <= 1)
		cmjust = CALIGN;
	else if (yywhcnt < 2)
		cmjust = CTRAIL;
	else
		cmjust = CRMARG;
	col = yycol - (cmdelim == '{' ? 1 : 2);
	cp = tree5(NIL, cmdelim, NIL, cmjust, yyseqid);
	cmeof = 0;
	do {
		kp = getcmline(cmdelim);
		if (cp->cml == NIL) {
			kp->cml = kp;
			kp->cmcol = col;
		} else {
			kp->cml = cp->cml->cml;
			cp->cml->cml = kp;
			switch (cp->cmjust) {
				case CTRAIL:
				case CRMARG:
					cp->cmjust = CALIGN;
			}
		}
		cp->cml = kp;
	} while (!cmeof);
	newcomm(cp);
	incomm = 0;
}

/*
 * Chain the new comment at "cp" onto the linked list of comments.
 */
newcomm(cp)
	register struct comment *cp;
{

	if (cmhp == NIL)
		cp->cmnext = cp;
	else {
		cp->cmnext = cmhp->cmnext;
		cmhp->cmnext = cp;
	}
	cmhp = cp;
}


int	nilcml[3];

quickcomm(t)
	int t;
{

	if (incomm)
		return;
	newcomm(tree5(nilcml, NIL, NIL, t, yyseqid));
}

commincl(cp, ch)
	char *cp, ch;
{

	newcomm(tree5(nilcml, savestr(cp), ch, CINCLUD, yyseqid));
}

getcmline(cmdelim)
	char cmdelim;
{
	char lastc;
	register char *tp;
	register CHAR c;
	register struct commline *kp;

	c = readch();
	kp = tree3(NIL, yycol, NIL);
	tp = token;
	lastc = 0;
	for (;;) {
		switch (c) {
			case '}':
				if (cmdelim == '{')
					goto endcm;
				break;
			case ')':
				if (cmdelim == '*' && lastc == '*') {
					--tp;
					goto endcm;
				}
				break;
			case '\n':
				goto done;
			case -1:
				yerror("Comment does not terminate - QUIT");
				pexit(ERRS);
		}
		lastc = c;
		*tp++ = c;
		c = readch();
	}
endcm:
	cmeof++;
done:
	*tp = 0;
	kp->cmtext = copystr(token);
	return (kp);
}

/*
 * Flush through the line this token is on.
 * Ignore if next token on same line as this one.
 */
putcml()
{
	register int i, SSeqid, SCol;

	if (Seqid == LSeqid)
		return (1);
	SSeqid = Seqid, SCol = Col;
	Seqid = LSeqid, Col = 32767;
	i = putcm();
	Seqid = SSeqid, Col = SCol;
	return (i);
}

/*
 * Flush to the beginning of the line this token is on.
 * Ignore if this token is on the same line as the previous one
 * (effectively since all such already then flushed.)
 */
putcmp()
{
	register int i, SSeqid, SCol;

	SSeqid = Seqid, SCol = Col;
	Seqid = LSeqid, Col = 0;
	i = putcm();
	Seqid = SSeqid, Col = SCol;
	return (i);
}

/*
 * Put out the comments to the border indicated by Seqid and Col
 */
putcm()
{
	register struct comment *cp;
	register int i;

	cp = cmhp;
	if (cp == NIL)
		return (0);
	i = 0;
	cp = cp->cmnext;
	while (cp->cmseqid < Seqid || cp->cmseqid == Seqid && cp->cml->cmcol < Col) {
		putone(cp);
		i =| 1 << cp->cmjust;
		if (cp->cmnext == cp) {
			cmhp = NIL;
			break;
		}
		cp = cp->cmnext;
		cmhp->cmnext = cp;
	}
	return (i);
}

/*
 * Put out one comment.
 * Note that empty lines, form feeds and #include statements
 * are treated as comments are regurgitated here.
 */
putone(cp)
	register struct comment *cp;
{
	register struct commline *cml, *cmf;

	align(cp);
	switch (cp->cmjust) {
		case CINCLUD:
		     /* ppflush() */
			if (noinclude == 0) {
				putchar('\f');
				return;
			}
			printf("#include %c%s%c", cp->cml, cp->cmdelim, cp->cml);
			return;
	}
	if (stripcomm)
		return;
	switch (cp->cmjust) {
		case CFORM:
			ppop("\f");
			ppnl();
		case CNL:
		case CNLBL:
			return;
	}
	ppbra(cp->cmdelim == '{' ? "{" : "(*");
	cmf = cp->cml->cml;
	ppid(cmf->cmtext);
	for (cml = cmf->cml; cml != cmf; cml = cml->cml) {
		align(cp);
		oneline(cmf->cmcol, cml);
	}
	ppket(cp->cmdelim == '{' ? "}" : "*)");
}

/*
 * Do the preliminary horizontal and vertical
 * motions necessary before beginning a comment,
 * or between lines of a mult-line comment.
 */
align(cp)
	register struct comment *cp;
{

	switch (cp->cmjust) {
		case CNL:
			ppsnl();
			break;
		case CNLBL:
			ppsnlb();
			break;
		case CFORM:
		case CINCLUD:
			ppnl();
			break;
		case CLMARG:
			ppnl();
			if (profile)
				ppid("\t");
			break;
		case CALIGN:
			ppnl();
			indent();
			break;
		case CTRAIL:
			ppspac();
			break;
		case CRMARG:
		case CSRMARG:
			pptab();
			break;
	}
}

/*
 * One line of a multi-line comment
 * Deal with alignment and initial white space trimming.
 * The "margin" indicates where the first line of the
 * comment began... don't print stuff in this comment
 * which came before this.
 */
oneline(margin, cml)
	int margin;
	struct commline *cml;
{
	register char *tp;
	register int i;

	for (i = 8, tp = cml->cmtext; i < margin && *tp; tp++)
		switch (*tp) {
			case ' ':
				i++;
				continue;
			case '\t':
				i =+ 8;
				i =& ~7;
				if (i < margin)
					continue;
				ppop("\t");
			default:
				goto out;
		}
out:
	ppid(tp);
}

/*
 * Flush all comments
 */
flushcm()
{

	Seqid = 32767;
	return(putcm());
}

#define	BLANKS	((1 << CNL) | (1 << CNLBL) | (1 << CFORM))
noblank(i)
	int i;
{

	return ((i & BLANKS) == 0);
}

int	needform, neednlbl, neednl, needseqid;

needtree()
{
	register struct comment *cp;

	needform = neednlbl = neednl = 0;
	cp = cmhp;
	if (cp == NIL)
		return (0);
	do {
		switch (cp->cmjust) {
			case CNL:
				neednl++;
				goto seq;
			case CNLBL:
				neednlbl++;
				goto seq;
			case CFORM:
				needform++;
seq:
				needseqid = cp->cmseqid;
				break;
			default:
				neednl = neednlbl = needform = 0;
				return (1);
		}
		cp = cp->cmnext;
	} while (cp != cmhp);
	cmhp = NIL;
	return (0);
}

packtree()
{
	int save;

	save = yyseqid;
	yyseqid = needseqid;
	for (; needform > 0; needform--)
		commform();
	for (; neednl > 0; neednl--)
		commnl();
	for (; neednlbl > 0; neednlbl--)
		commnlbl();
	yyseqid = save;
}
Commit	Line	Data
731f59cf BJ	1	/* Copyright (c) 1979 Regents of the University of California */
	2	#
	3	/*
	4	* pxp - Pascal execution profiler
	5	*
	6	* Bill Joy UCB
	7	* Version 1.2 January 1979
	8	*/
	9
	10	#include "0.h"
	11	#include "yy.h"
	12
	13	/*
	14	* COMMENT PROCESSING CLUSTER
	15	*
	16	* The global organization of this cluster is as follows.
	17	* While parsing the program information is saved in the tree which
	18	* tells the source text coordinates (sequence numbers and columns)
	19	* bounding each production. The comments from the source program
	20	* are also saved, with information about their source text position
	21	* and a classification as to their kind.
	22	*
	23	* When printing the reformatted program we flush out the comments
	24	* at various points using the information in the comments and the parse
	25	* tree to "resynchronize". A number of special cases are recognized to
	26	* deal with the vagarities of producing a true "fixed point" so that
	27	* a prettyprinted program will re-prettyprint to itself.
	28	*/
	29
	30	/*
	31	* Save sequence id's and column markers bounding a production
	32	* for later use in placing comments. We save the sequence id
	33	* and column of the leftmost token and the following token, and
	34	* the sequence id of the last token in this reduction.
	35	* See putcm, putcml, and putcmp below for motivation.
	36	*/
	37	line2of(l)
	38	int l;
	39	{
	40
	41	return (lineNof(l, 2));
	42	}
	43
	44	lineof(l)
	45	int l;
	46	{
	47
	48	return (lineNof(l, 1));
	49	}
	50
	51	lineNof(l, i)
	52	int l, i;
	53	{
	54
	55	return(tree(6, l, yypw[i].Wseqid, yypw[i].Wcol, yyseqid, yycol, yypw[N].Wseqid));
	56	}
	57
	58	/*
	59	* After a call to setline, Seqid is set to the sequence id
	60	* of the symbol which followed the reduction in which the
	61	* lineof call was embedded, Col to the associated column,
	62	* and LSeqid to the sequence id of the last symbol in the reduction
	63	* (Note that this is exact only if the last symbol was a terminal
	64	* this is always true when it matters.)
65	*/
66	int Seqid, Col, LSeqid;
67
68	/*
69	* Retrieve the information from a call to lineof before beginning the
70	* output of a tree from a reduction. First flush to the left margin
71	* of the production, and then set so that later calls to putcm, putcml
72	* and putcmp will deal with the right margin of this comment.
73	*
74	* The routine setinfo is called when the lineof has no embedded line
75	* number to avoid trashing the current "line".
76	*
77	* The routine setinfo is often called after completing the output of
78	* the text of a tree to restore Seqid, Col, and LSeqid which may have
79	* been destroyed by the nested processing calls to setline.
80	* In this case the only effect of the call to setinfo is to
81	* modify the above three variables as a side effect.
82	*
83	* We return a word giving information about the comments which were
84	* actually put out. See putcm for details.
85	*/
86	setline(ip)
87	int *ip;
88	{
89
90	line = ip[0];
91	return(setinfo(ip));
92	}
93
94	setinfo(ip)
95	register int *ip;
96	{
97	register int i;
98
99	ip++;
100	Seqid = *ip++;
101	Col = *ip++;
102	i = putcm();
103	Seqid = *ip++;
104	Col = *ip++;
105	LSeqid = *ip++;
106	return (i);
107	}
108
109	char cmeof, incomm;
110
111	/*
112	* Get the text of a comment from the input stream,
113	* recording its type and linking it into the linked
114	* list of comments headed by cmhp.
115	*/
116	getcm(cmdelim)
117	char cmdelim;
118	{
119	int cmjust, col;
120	register struct comment *cp;
121	register struct commline *kp;
122
123	incomm = 1;
124	if (cmdelim == '*' && yycol == 10 \|\| cmdelim == '{' && yycol == 9)
125	cmjust = CLMARG;
126	else if (yytokcnt <= 1)
127	cmjust = CALIGN;
128	else if (yywhcnt < 2)
129	cmjust = CTRAIL;
130	else
131	cmjust = CRMARG;
132	col = yycol - (cmdelim == '{' ? 1 : 2);
133	cp = tree5(NIL, cmdelim, NIL, cmjust, yyseqid);
134	cmeof = 0;
135	do {
136	kp = getcmline(cmdelim);
137	if (cp->cml == NIL) {
138	kp->cml = kp;
139	kp->cmcol = col;
140	} else {
141	kp->cml = cp->cml->cml;
142	cp->cml->cml = kp;
143	switch (cp->cmjust) {
144	case CTRAIL:
145	case CRMARG:
146	cp->cmjust = CALIGN;
147	}
148	}
149	cp->cml = kp;
150	} while (!cmeof);
151	newcomm(cp);
152	incomm = 0;
153	}
154
155	/*
156	* Chain the new comment at "cp" onto the linked list of comments.
157	*/
158	newcomm(cp)
159	register struct comment *cp;
160	{
161
162	if (cmhp == NIL)
163	cp->cmnext = cp;
164	else {
165	cp->cmnext = cmhp->cmnext;
166	cmhp->cmnext = cp;
167	}
168	cmhp = cp;
169	}
170
171
172	int nilcml[3];
173
174	quickcomm(t)
175	int t;
176	{
177
178	if (incomm)
179	return;
180	newcomm(tree5(nilcml, NIL, NIL, t, yyseqid));
181	}
182
183	commincl(cp, ch)
184	char *cp, ch;
185	{
186
187	newcomm(tree5(nilcml, savestr(cp), ch, CINCLUD, yyseqid));
188	}
189
190	getcmline(cmdelim)
191	char cmdelim;
192	{
193	char lastc;
194	register char *tp;
195	register CHAR c;
196	register struct commline *kp;
197
198	c = readch();
199	kp = tree3(NIL, yycol, NIL);
200	tp = token;
201	lastc = 0;
202	for (;;) {
203	switch (c) {
204	case '}':
205	if (cmdelim == '{')
206	goto endcm;
207	break;
208	case ')':
209	if (cmdelim == '' && lastc == '') {
210	--tp;
211	goto endcm;
212	}
213	break;
214	case '\n':
215	goto done;
216	case -1:
217	yerror("Comment does not terminate - QUIT");
218	pexit(ERRS);
219	}
220	lastc = c;
221	*tp++ = c;
222	c = readch();
223	}
224	endcm:
225	cmeof++;
226	done:
227	*tp = 0;
228	kp->cmtext = copystr(token);
229	return (kp);
230	}
231
232	/*
233	* Flush through the line this token is on.
234	* Ignore if next token on same line as this one.
235	*/
236	putcml()
237	{
238	register int i, SSeqid, SCol;
239
240	if (Seqid == LSeqid)
241	return (1);
242	SSeqid = Seqid, SCol = Col;
243	Seqid = LSeqid, Col = 32767;
244	i = putcm();
245	Seqid = SSeqid, Col = SCol;
246	return (i);
247	}
248
249	/*
250	* Flush to the beginning of the line this token is on.
251	* Ignore if this token is on the same line as the previous one
252	* (effectively since all such already then flushed.)
253	*/
254	putcmp()
255	{
256	register int i, SSeqid, SCol;
257
258	SSeqid = Seqid, SCol = Col;
259	Seqid = LSeqid, Col = 0;
260	i = putcm();
261	Seqid = SSeqid, Col = SCol;
262	return (i);
263	}
264
265	/*
266	* Put out the comments to the border indicated by Seqid and Col
267	*/
268	putcm()
269	{
270	register struct comment *cp;
271	register int i;
272
273	cp = cmhp;
274	if (cp == NIL)
275	return (0);
276	i = 0;
277	cp = cp->cmnext;
278	while (cp->cmseqid < Seqid \|\| cp->cmseqid == Seqid && cp->cml->cmcol < Col) {
279	putone(cp);
280	i =\| 1 << cp->cmjust;
281	if (cp->cmnext == cp) {
282	cmhp = NIL;
283	break;
284	}
285	cp = cp->cmnext;
286	cmhp->cmnext = cp;
287	}
288	return (i);
289	}
290
291	/*
292	* Put out one comment.
293	* Note that empty lines, form feeds and #include statements
294	* are treated as comments are regurgitated here.
295	*/
296	putone(cp)
297	register struct comment *cp;
298	{
299	register struct commline cml, cmf;
300
301	align(cp);
302	switch (cp->cmjust) {
303	case CINCLUD:
304	/* ppflush() */
305	if (noinclude == 0) {
306	putchar('\f');
307	return;
308	}
309	printf("#include %c%s%c", cp->cml, cp->cmdelim, cp->cml);
310	return;
311	}
312	if (stripcomm)
313	return;
314	switch (cp->cmjust) {
315	case CFORM:
316	ppop("\f");
317	ppnl();
318	case CNL:
319	case CNLBL:
320	return;
321	}
322	ppbra(cp->cmdelim == '{' ? "{" : "(*");
323	cmf = cp->cml->cml;
324	ppid(cmf->cmtext);
325	for (cml = cmf->cml; cml != cmf; cml = cml->cml) {
326	align(cp);
327	oneline(cmf->cmcol, cml);
328	}
329	ppket(cp->cmdelim == '{' ? "}" : "*)");
330	}
331
332	/*
333	* Do the preliminary horizontal and vertical
334	* motions necessary before beginning a comment,
335	* or between lines of a mult-line comment.
336	*/
337	align(cp)
338	register struct comment *cp;
339	{
340
341	switch (cp->cmjust) {
342	case CNL:
343	ppsnl();
344	break;
345	case CNLBL:
346	ppsnlb();
347	break;
348	case CFORM:
349	case CINCLUD:
350	ppnl();
351	break;
352	case CLMARG:
353	ppnl();
354	if (profile)
355	ppid("\t");
356	break;
357	case CALIGN:
358	ppnl();
359	indent();
360	break;
361	case CTRAIL:
362	ppspac();
363	break;
364	case CRMARG:
365	case CSRMARG:
366	pptab();
367	break;
368	}
369	}
370
371	/*
372	* One line of a multi-line comment
373	* Deal with alignment and initial white space trimming.
374	* The "margin" indicates where the first line of the
375	* comment began... don't print stuff in this comment
376	* which came before this.
377	*/
378	oneline(margin, cml)
379	int margin;
380	struct commline *cml;
381	{
382	register char *tp;
383	register int i;
384
385	for (i = 8, tp = cml->cmtext; i < margin && *tp; tp++)
386	switch (*tp) {
387	case ' ':
388	i++;
389	continue;
390	case '\t':
391	i =+ 8;
392	i =& ~7;
393	if (i < margin)
394	continue;
395	ppop("\t");
396	default:
397	goto out;
398	}
399	out:
400	ppid(tp);
401	}
402
403	/*
404	* Flush all comments
405	*/
406	flushcm()
407	{
408
409	Seqid = 32767;
410	return(putcm());
411	}
412
413	#define BLANKS ((1 << CNL) \| (1 << CNLBL) \| (1 << CFORM))
414	noblank(i)
415	int i;
416	{
417
418	return ((i & BLANKS) == 0);
419	}
420
421	int needform, neednlbl, neednl, needseqid;
422
423	needtree()
424	{
425	register struct comment *cp;
426
427	needform = neednlbl = neednl = 0;
428	cp = cmhp;
429	if (cp == NIL)
430	return (0);
431	do {
432	switch (cp->cmjust) {
433	case CNL:
434	neednl++;
435	goto seq;
436	case CNLBL:
437	neednlbl++;
438	goto seq;
439	case CFORM:
440	needform++;
441	seq:
442	needseqid = cp->cmseqid;
443	break;
444	default:
445	neednl = neednlbl = needform = 0;
446	return (1);
447	}
448	cp = cp->cmnext;
449	} while (cp != cmhp);
450	cmhp = NIL;
451	return (0);
452	}
453
454	packtree()
455	{
456	int save;
457
458	save = yyseqid;
459	yyseqid = needseqid;
460	for (; needform > 0; needform--)
461	commform();
462	for (; neednl > 0; neednl--)
463	commnl();
464	for (; neednlbl > 0; neednlbl--)
465	commnlbl();
466	yyseqid = save;
467	}