xref: /dragonfly/usr.bin/indent/parse.c (revision 110def69) 
1 /*
2  * Copyright (c) 1985 Sun Microsystems, Inc.
3  * Copyright (c) 1980, 1993
4  *	The Regents of the University of California.  All rights reserved.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  * @(#)parse.c	8.1 (Berkeley) 6/6/93
32  * $FreeBSD: src/usr.bin/indent/parse.c,v 1.10 2003/06/15 09:28:17 charnier Exp $
33  */
34 
35 #include <stdio.h>
36 #include "indent_globs.h"
37 #include "indent_codes.h"
38 #include "indent.h"
39 
40 static void reduce(void);
41 
42 void
43 parse(int tk) /* tk: the code for the construct scanned */
44 {
45     int         i;
46 
47 #ifdef debug
48     printf("%2d - %s\n", tk, token);
49 #endif
50 
51     while (ps.p_stack[ps.tos] == ifhead && tk != elselit) {
52 	/* true if we have an if without an else */
53 	ps.p_stack[ps.tos] = stmt;	/* apply the if(..) stmt ::= stmt
54 					 * reduction */
55 	reduce();		/* see if this allows any reduction */
56     }
57 
58 
59     switch (tk) {		/* go on and figure out what to do with the
60 				 * input */
61 
62     case decl:			/* scanned a declaration word */
63 	ps.search_brace = btype_2;
64 	/* indicate that following brace should be on same line */
65 	if (ps.p_stack[ps.tos] != decl) {	/* only put one declaration
66 						 * onto stack */
67 	    break_comma = true;	/* while in declaration, newline should be
68 				 * forced after comma */
69 	    ps.p_stack[++ps.tos] = decl;
70 	    ps.il[ps.tos] = ps.i_l_follow;
71 
72 	    if (ps.ljust_decl) {/* only do if we want left justified
73 				 * declarations */
74 		ps.ind_level = 0;
75 		for (i = ps.tos - 1; i > 0; --i)
76 		    if (ps.p_stack[i] == decl)
77 			++ps.ind_level;	/* indentation is number of
78 					 * declaration levels deep we are */
79 		ps.i_l_follow = ps.ind_level;
80 	    }
81 	}
82 	break;
83 
84     case ifstmt:		/* scanned if (...) */
85 	if (ps.p_stack[ps.tos] == elsehead && ps.else_if)	/* "else if ..." */
86 	    ps.i_l_follow = ps.il[ps.tos];
87 	/* FALLTHROUGH */
88     case dolit:		/* 'do' */
89     case forstmt:		/* for (...) */
90 	ps.p_stack[++ps.tos] = tk;
91 	ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
92 	++ps.i_l_follow;	/* subsequent statements should be indented 1 */
93 	ps.search_brace = btype_2;
94 	break;
95 
96     case lbrace:		/* scanned { */
97 	break_comma = false;	/* don't break comma in an initial list */
98 	if (ps.p_stack[ps.tos] == stmt || ps.p_stack[ps.tos] == decl
99 		|| ps.p_stack[ps.tos] == stmtl)
100 	    ++ps.i_l_follow;	/* it is a random, isolated stmt group or a
101 				 * declaration */
102 	else {
103 	    if (s_code == e_code) {
104 		/*
105 		 * only do this if there is nothing on the line
106 		 */
107 		--ps.ind_level;
108 		/*
109 		 * it is a group as part of a while, for, etc.
110 		 */
111 		if (ps.p_stack[ps.tos] == swstmt && ps.case_indent >= 1)
112 		    --ps.ind_level;
113 		/*
114 		 * for a switch, brace should be two levels out from the code
115 		 */
116 	    }
117 	}
118 
119 	ps.p_stack[++ps.tos] = lbrace;
120 	ps.il[ps.tos] = ps.ind_level;
121 	ps.p_stack[++ps.tos] = stmt;
122 	/* allow null stmt between braces */
123 	ps.il[ps.tos] = ps.i_l_follow;
124 	break;
125 
126     case whilestmt:		/* scanned while (...) */
127 	if (ps.p_stack[ps.tos] == dohead) {
128 	    /* it is matched with do stmt */
129 	    ps.ind_level = ps.i_l_follow = ps.il[ps.tos];
130 	    ps.p_stack[++ps.tos] = whilestmt;
131 	    ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
132 	}
133 	else {			/* it is a while loop */
134 	    ps.p_stack[++ps.tos] = whilestmt;
135 	    ps.il[ps.tos] = ps.i_l_follow;
136 	    ++ps.i_l_follow;
137 	    ps.search_brace = btype_2;
138 	}
139 
140 	break;
141 
142     case elselit:		/* scanned an else */
143 
144 	if (ps.p_stack[ps.tos] != ifhead)
145 	    diag2(1, "Unmatched 'else'");
146 	else {
147 	    ps.ind_level = ps.il[ps.tos];	/* indentation for else should
148 						 * be same as for if */
149 	    ps.i_l_follow = ps.ind_level + 1;	/* everything following should
150 						 * be in 1 level */
151 	    ps.p_stack[ps.tos] = elsehead;
152 	    /* remember if with else */
153 	    ps.search_brace = btype_2 | ps.else_if;
154 	}
155 	break;
156 
157     case rbrace:		/* scanned a } */
158 	/* stack should have <lbrace> <stmt> or <lbrace> <stmtl> */
159 	if (ps.p_stack[ps.tos - 1] == lbrace) {
160 	    ps.ind_level = ps.i_l_follow = ps.il[--ps.tos];
161 	    ps.p_stack[ps.tos] = stmt;
162 	}
163 	else
164 	    diag2(1, "Statement nesting error");
165 	break;
166 
167     case swstmt:		/* had switch (...) */
168 	ps.p_stack[++ps.tos] = swstmt;
169 	ps.cstk[ps.tos] = case_ind;
170 	/* save current case indent level */
171 	ps.il[ps.tos] = ps.i_l_follow;
172 	case_ind = ps.i_l_follow + ps.case_indent;	/* cases should be one
173 							 * level down from
174 							 * switch */
175 	ps.i_l_follow += ps.case_indent + 1;	/* statements should be two
176 						 * levels in */
177 	ps.search_brace = btype_2;
178 	break;
179 
180     case semicolon:		/* this indicates a simple stmt */
181 	break_comma = false;	/* turn off flag to break after commas in a
182 				 * declaration */
183 	ps.p_stack[++ps.tos] = stmt;
184 	ps.il[ps.tos] = ps.ind_level;
185 	break;
186 
187     default:			/* this is an error */
188 	diag2(1, "Unknown code to parser");
189 	return;
190 
191 
192     }				/* end of switch */
193 
194     reduce();			/* see if any reduction can be done */
195 
196 #ifdef debug
197     for (i = 1; i <= ps.tos; ++i)
198 	printf("(%d %d)", ps.p_stack[i], ps.il[i]);
199     printf("\n");
200 #endif
201 
202     return;
203 }
204 
205 /*
206  * NAME: reduce
207  *
208  * FUNCTION: Implements the reduce part of the parsing algorithm
209  *
210  * ALGORITHM: The following reductions are done.  Reductions are repeated
211  *	until no more are possible.
212  *
213  * Old TOS		New TOS
214  * <stmt> <stmt>	<stmtl>
215  * <stmtl> <stmt>	<stmtl>
216  * do <stmt>		"dostmt"
217  * if <stmt>		"ifstmt"
218  * switch <stmt>	<stmt>
219  * decl <stmt>		<stmt>
220  * "ifelse" <stmt>	<stmt>
221  * for <stmt>		<stmt>
222  * while <stmt>		<stmt>
223  * "dostmt" while	<stmt>
224  *
225  * On each reduction, ps.i_l_follow (the indentation for the following line)
226  * is set to the indentation level associated with the old TOS.
227  *
228  * PARAMETERS: None
229  *
230  * RETURNS: Nothing
231  *
232  * GLOBALS: ps.cstk ps.i_l_follow = ps.il ps.p_stack = ps.tos =
233  *
234  * CALLS: None
235  *
236  * CALLED BY: parse
237  *
238  * HISTORY: initial coding 	November 1976	D A Willcox of CAC
239  *
240  */
241 /*----------------------------------------------*\
242 |   REDUCTION PHASE				    |
243 \*----------------------------------------------*/
244 static void
245 reduce(void)
246 {
247     int i;
248 
249     for (;;) {			/* keep looping until there is nothing left to
250 				 * reduce */
251 
252 	switch (ps.p_stack[ps.tos]) {
253 
254 	case stmt:
255 	    switch (ps.p_stack[ps.tos - 1]) {
256 
257 	    case stmt:
258 	    case stmtl:
259 		/* stmtl stmt or stmt stmt */
260 		ps.p_stack[--ps.tos] = stmtl;
261 		break;
262 
263 	    case dolit:	/* <do> <stmt> */
264 		ps.p_stack[--ps.tos] = dohead;
265 		ps.i_l_follow = ps.il[ps.tos];
266 		break;
267 
268 	    case ifstmt:
269 		/* <if> <stmt> */
270 		ps.p_stack[--ps.tos] = ifhead;
271 		for (i = ps.tos - 1;
272 			(
273 			 ps.p_stack[i] != stmt
274 			 &&
275 			 ps.p_stack[i] != stmtl
276 			 &&
277 			 ps.p_stack[i] != lbrace
278 			 );
279 			--i);
280 		ps.i_l_follow = ps.il[i];
281 		/*
282 		 * for the time being, we will assume that there is no else on
283 		 * this if, and set the indentation level accordingly. If an
284 		 * else is scanned, it will be fixed up later
285 		 */
286 		break;
287 
288 	    case swstmt:
289 		/* <switch> <stmt> */
290 		case_ind = ps.cstk[ps.tos - 1];
291 		/* FALLTHROUGH */
292 	    case decl:		/* finish of a declaration */
293 	    case elsehead:
294 		/* <<if> <stmt> else> <stmt> */
295 	    case forstmt:
296 		/* <for> <stmt> */
297 	    case whilestmt:
298 		/* <while> <stmt> */
299 		ps.p_stack[--ps.tos] = stmt;
300 		ps.i_l_follow = ps.il[ps.tos];
301 		break;
302 
303 	    default:		/* <anything else> <stmt> */
304 		return;
305 
306 	    }			/* end of section for <stmt> on top of stack */
307 	    break;
308 
309 	case whilestmt:	/* while (...) on top */
310 	    if (ps.p_stack[ps.tos - 1] == dohead) {
311 		/* it is termination of a do while */
312 		ps.tos -= 2;
313 		break;
314 	    }
315 	    else
316 		return;
317 
318 	default:		/* anything else on top */
319 	    return;
320 
321 	}
322     }
323 }
324