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