indent.c revision 1.164 1 1.164 rillig /* $NetBSD: indent.c,v 1.164 2021/10/28 21:51:43 rillig Exp $ */
2 1.4 tls
3 1.25 kamil /*-
4 1.25 kamil * SPDX-License-Identifier: BSD-4-Clause
5 1.25 kamil *
6 1.25 kamil * Copyright (c) 1985 Sun Microsystems, Inc.
7 1.25 kamil * Copyright (c) 1976 Board of Trustees of the University of Illinois.
8 1.5 mrg * Copyright (c) 1980, 1993
9 1.5 mrg * The Regents of the University of California. All rights reserved.
10 1.15 agc *
11 1.15 agc * Redistribution and use in source and binary forms, with or without
12 1.15 agc * modification, are permitted provided that the following conditions
13 1.15 agc * are met:
14 1.15 agc * 1. Redistributions of source code must retain the above copyright
15 1.15 agc * notice, this list of conditions and the following disclaimer.
16 1.15 agc * 2. Redistributions in binary form must reproduce the above copyright
17 1.15 agc * notice, this list of conditions and the following disclaimer in the
18 1.15 agc * documentation and/or other materials provided with the distribution.
19 1.1 cgd * 3. All advertising materials mentioning features or use of this software
20 1.1 cgd * must display the following acknowledgement:
21 1.1 cgd * This product includes software developed by the University of
22 1.1 cgd * California, Berkeley and its contributors.
23 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
24 1.1 cgd * may be used to endorse or promote products derived from this software
25 1.1 cgd * without specific prior written permission.
26 1.1 cgd *
27 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 1.1 cgd * SUCH DAMAGE.
38 1.1 cgd */
39 1.1 cgd
40 1.25 kamil #if 0
41 1.25 kamil static char sccsid[] = "@(#)indent.c 5.17 (Berkeley) 6/7/93";
42 1.25 kamil #endif
43 1.1 cgd
44 1.25 kamil #include <sys/cdefs.h>
45 1.25 kamil #if defined(__NetBSD__)
46 1.164 rillig __RCSID("$NetBSD: indent.c,v 1.164 2021/10/28 21:51:43 rillig Exp $");
47 1.25 kamil #elif defined(__FreeBSD__)
48 1.25 kamil __FBSDID("$FreeBSD: head/usr.bin/indent/indent.c 340138 2018-11-04 19:24:49Z oshogbo $");
49 1.25 kamil #endif
50 1.1 cgd
51 1.1 cgd #include <sys/param.h>
52 1.25 kamil #if HAVE_CAPSICUM
53 1.25 kamil #include <sys/capsicum.h>
54 1.25 kamil #include <capsicum_helpers.h>
55 1.25 kamil #endif
56 1.82 rillig #include <ctype.h>
57 1.6 lukem #include <err.h>
58 1.6 lukem #include <errno.h>
59 1.1 cgd #include <fcntl.h>
60 1.1 cgd #include <stdio.h>
61 1.1 cgd #include <stdlib.h>
62 1.1 cgd #include <string.h>
63 1.82 rillig #include <unistd.h>
64 1.29 rillig
65 1.25 kamil #include "indent.h"
66 1.25 kamil
67 1.71 rillig struct options opt = {
68 1.122 rillig .brace_same_line = true,
69 1.86 rillig .comment_delimiter_on_blankline = true,
70 1.86 rillig .cuddle_else = true,
71 1.86 rillig .comment_column = 33,
72 1.86 rillig .decl_indent = 16,
73 1.86 rillig .else_if = true,
74 1.86 rillig .function_brace_split = true,
75 1.86 rillig .format_col1_comments = true,
76 1.86 rillig .format_block_comments = true,
77 1.86 rillig .indent_parameters = true,
78 1.86 rillig .indent_size = 8,
79 1.86 rillig .local_decl_indent = -1,
80 1.86 rillig .lineup_to_parens = true,
81 1.86 rillig .procnames_start_line = true,
82 1.86 rillig .star_comment_cont = true,
83 1.86 rillig .tabsize = 8,
84 1.86 rillig .max_line_length = 78,
85 1.86 rillig .use_tabs = true,
86 1.71 rillig };
87 1.71 rillig
88 1.27 joerg struct parser_state ps;
89 1.27 joerg
90 1.63 rillig struct buffer lab;
91 1.65 rillig struct buffer code;
92 1.63 rillig struct buffer com;
93 1.67 rillig struct buffer token;
94 1.27 joerg
95 1.124 rillig struct buffer inp;
96 1.86 rillig
97 1.86 rillig char sc_buf[sc_size];
98 1.86 rillig char *save_com;
99 1.88 rillig static char *sc_end; /* pointer into save_com buffer */
100 1.86 rillig
101 1.125 rillig char *saved_inp_s;
102 1.125 rillig char *saved_inp_e;
103 1.86 rillig
104 1.86 rillig bool found_err;
105 1.140 rillig int blank_lines_to_output;
106 1.142 rillig bool blank_line_before;
107 1.142 rillig bool blank_line_after;
108 1.86 rillig bool break_comma;
109 1.86 rillig float case_ind;
110 1.86 rillig bool had_eof;
111 1.86 rillig int line_no;
112 1.86 rillig bool inhibit_formatting;
113 1.27 joerg
114 1.88 rillig static int ifdef_level;
115 1.88 rillig static struct parser_state state_stack[5];
116 1.27 joerg
117 1.86 rillig FILE *input;
118 1.86 rillig FILE *output;
119 1.27 joerg
120 1.88 rillig static const char *in_name = "Standard Input";
121 1.88 rillig static const char *out_name = "Standard Output";
122 1.88 rillig static const char *backup_suffix = ".BAK";
123 1.88 rillig static char bakfile[MAXPATHLEN] = "";
124 1.1 cgd
125 1.40 rillig #if HAVE_CAPSICUM
126 1.40 rillig static void
127 1.40 rillig init_capsicum(void)
128 1.1 cgd {
129 1.25 kamil cap_rights_t rights;
130 1.40 rillig
131 1.40 rillig /* Restrict input/output descriptors and enter Capsicum sandbox. */
132 1.40 rillig cap_rights_init(&rights, CAP_FSTAT, CAP_WRITE);
133 1.40 rillig if (caph_rights_limit(fileno(output), &rights) < 0)
134 1.40 rillig err(EXIT_FAILURE, "unable to limit rights for %s", out_name);
135 1.40 rillig cap_rights_init(&rights, CAP_FSTAT, CAP_READ);
136 1.40 rillig if (caph_rights_limit(fileno(input), &rights) < 0)
137 1.40 rillig err(EXIT_FAILURE, "unable to limit rights for %s", in_name);
138 1.40 rillig if (caph_enter() < 0)
139 1.40 rillig err(EXIT_FAILURE, "unable to enter capability mode");
140 1.40 rillig }
141 1.41 rillig #endif
142 1.41 rillig
143 1.148 rillig void
144 1.148 rillig diag(int level, const char *msg, ...)
145 1.148 rillig {
146 1.148 rillig va_list ap;
147 1.148 rillig
148 1.148 rillig if (level != 0)
149 1.148 rillig found_err = true;
150 1.148 rillig
151 1.148 rillig va_start(ap, msg);
152 1.148 rillig fprintf(stderr, "%s: %s:%d: ",
153 1.148 rillig level == 0 ? "warning" : "error", in_name, line_no);
154 1.148 rillig vfprintf(stderr, msg, ap);
155 1.148 rillig fprintf(stderr, "\n");
156 1.148 rillig va_end(ap);
157 1.148 rillig }
158 1.148 rillig
159 1.41 rillig static void
160 1.158 rillig search_stmt_newline(bool *force_nl)
161 1.91 rillig {
162 1.91 rillig if (sc_end == NULL) {
163 1.91 rillig save_com = sc_buf;
164 1.91 rillig save_com[0] = save_com[1] = ' ';
165 1.91 rillig sc_end = &save_com[2];
166 1.91 rillig }
167 1.91 rillig *sc_end++ = '\n';
168 1.91 rillig
169 1.147 rillig line_no++;
170 1.147 rillig
171 1.91 rillig /*
172 1.92 rillig * We may have inherited a force_nl == true from the previous token (like
173 1.92 rillig * a semicolon). But once we know that a newline has been scanned in this
174 1.92 rillig * loop, force_nl should be false.
175 1.91 rillig *
176 1.92 rillig * However, the force_nl == true must be preserved if newline is never
177 1.92 rillig * scanned in this loop, so this assignment cannot be done earlier.
178 1.91 rillig */
179 1.104 rillig *force_nl = false;
180 1.91 rillig }
181 1.91 rillig
182 1.91 rillig static void
183 1.158 rillig search_stmt_comment(bool *comment_buffered)
184 1.91 rillig {
185 1.91 rillig if (sc_end == NULL) {
186 1.91 rillig /*
187 1.91 rillig * Copy everything from the start of the line, because
188 1.92 rillig * process_comment() will use that to calculate original indentation
189 1.92 rillig * of a boxed comment.
190 1.91 rillig */
191 1.124 rillig memcpy(sc_buf, inp.buf, (size_t)(inp.s - inp.buf) - 4);
192 1.124 rillig save_com = sc_buf + (inp.s - inp.buf - 4);
193 1.91 rillig save_com[0] = save_com[1] = ' ';
194 1.91 rillig sc_end = &save_com[2];
195 1.91 rillig }
196 1.119 rillig
197 1.104 rillig *comment_buffered = true;
198 1.92 rillig *sc_end++ = '/'; /* copy in start of comment */
199 1.91 rillig *sc_end++ = '*';
200 1.119 rillig
201 1.92 rillig for (;;) { /* loop until the end of the comment */
202 1.100 rillig *sc_end++ = inbuf_next();
203 1.124 rillig if (sc_end[-1] == '*' && *inp.s == '/')
204 1.92 rillig break; /* we are at end of comment */
205 1.91 rillig if (sc_end >= &save_com[sc_size]) { /* check for temp buffer
206 1.91 rillig * overflow */
207 1.91 rillig diag(1, "Internal buffer overflow - Move big comment from right after if, while, or whatever");
208 1.91 rillig fflush(output);
209 1.91 rillig exit(1);
210 1.91 rillig }
211 1.91 rillig }
212 1.119 rillig
213 1.92 rillig *sc_end++ = '/'; /* add ending slash */
214 1.99 rillig inbuf_skip(); /* get past / in buffer */
215 1.91 rillig }
216 1.91 rillig
217 1.91 rillig static bool
218 1.158 rillig search_stmt_lbrace(void)
219 1.91 rillig {
220 1.91 rillig /*
221 1.92 rillig * Put KNF-style lbraces before the buffered up tokens and jump out of
222 1.117 rillig * this loop in order to avoid copying the token again.
223 1.91 rillig */
224 1.122 rillig if (sc_end != NULL && opt.brace_same_line) {
225 1.91 rillig save_com[0] = '{';
226 1.91 rillig /*
227 1.92 rillig * Originally the lbrace may have been alone on its own line, but it
228 1.92 rillig * will be moved into "the else's line", so if there was a newline
229 1.92 rillig * resulting from the "{" before, it must be scanned now and ignored.
230 1.91 rillig */
231 1.124 rillig while (isspace((unsigned char)*inp.s)) {
232 1.99 rillig inbuf_skip();
233 1.124 rillig if (*inp.s == '\n')
234 1.91 rillig break;
235 1.91 rillig }
236 1.91 rillig return true;
237 1.91 rillig }
238 1.91 rillig return false;
239 1.91 rillig }
240 1.91 rillig
241 1.91 rillig static bool
242 1.158 rillig search_stmt_other(lexer_symbol lsym, bool *force_nl,
243 1.91 rillig bool comment_buffered, bool last_else)
244 1.91 rillig {
245 1.91 rillig bool remove_newlines;
246 1.91 rillig
247 1.91 rillig remove_newlines =
248 1.160 rillig /* "} else" */
249 1.160 rillig (lsym == lsym_else && code.e != code.s && code.e[-1] == '}')
250 1.160 rillig /* "else if" */
251 1.160 rillig || (lsym == lsym_if && last_else && opt.else_if);
252 1.91 rillig if (remove_newlines)
253 1.104 rillig *force_nl = false;
254 1.119 rillig
255 1.91 rillig if (sc_end == NULL) { /* ignore buffering if comment wasn't saved
256 1.91 rillig * up */
257 1.158 rillig ps.search_stmt = false;
258 1.91 rillig return false;
259 1.91 rillig }
260 1.119 rillig
261 1.120 rillig while (sc_end > save_com && isblank((unsigned char)sc_end[-1]))
262 1.91 rillig sc_end--;
263 1.119 rillig
264 1.91 rillig if (opt.swallow_optional_blanklines ||
265 1.91 rillig (!comment_buffered && remove_newlines)) {
266 1.104 rillig *force_nl = !remove_newlines;
267 1.91 rillig while (sc_end > save_com && sc_end[-1] == '\n') {
268 1.91 rillig sc_end--;
269 1.91 rillig }
270 1.91 rillig }
271 1.119 rillig
272 1.117 rillig if (*force_nl) { /* if we should insert a nl here, put it into
273 1.91 rillig * the buffer */
274 1.104 rillig *force_nl = false;
275 1.91 rillig --line_no; /* this will be re-increased when the newline
276 1.91 rillig * is read from the buffer */
277 1.91 rillig *sc_end++ = '\n';
278 1.91 rillig *sc_end++ = ' ';
279 1.117 rillig if (opt.verbose) /* warn if the line was not already broken */
280 1.91 rillig diag(0, "Line broken");
281 1.91 rillig }
282 1.119 rillig
283 1.135 rillig /* XXX: buffer overflow? This is essentially a strcpy. */
284 1.91 rillig for (const char *t_ptr = token.s; *t_ptr != '\0'; ++t_ptr)
285 1.91 rillig *sc_end++ = *t_ptr;
286 1.91 rillig return true;
287 1.91 rillig }
288 1.91 rillig
289 1.91 rillig static void
290 1.91 rillig switch_buffer(void)
291 1.91 rillig {
292 1.158 rillig ps.search_stmt = false;
293 1.139 rillig saved_inp_s = inp.s; /* save current input buffer */
294 1.125 rillig saved_inp_e = inp.e;
295 1.124 rillig inp.s = save_com; /* fix so that subsequent calls to lexi will
296 1.91 rillig * take tokens out of save_com */
297 1.91 rillig *sc_end++ = ' '; /* add trailing blank, just in case */
298 1.124 rillig inp.e = sc_end;
299 1.91 rillig sc_end = NULL;
300 1.124 rillig debug_println("switched inp.s to save_com");
301 1.91 rillig }
302 1.91 rillig
303 1.91 rillig static void
304 1.158 rillig search_stmt_lookahead(lexer_symbol *lsym)
305 1.91 rillig {
306 1.156 rillig if (*lsym == lsym_eof)
307 1.115 rillig return;
308 1.115 rillig
309 1.91 rillig /*
310 1.149 rillig * The only intended purpose of calling lexi() below is to categorize the
311 1.149 rillig * next token in order to decide whether to continue buffering forthcoming
312 1.149 rillig * tokens. Once the buffering is over, lexi() will be called again
313 1.149 rillig * elsewhere on all of the tokens - this time for normal processing.
314 1.115 rillig *
315 1.149 rillig * Calling it for this purpose is a bug, because lexi() also changes the
316 1.149 rillig * parser state and discards leading whitespace, which is needed mostly
317 1.149 rillig * for comment-related considerations.
318 1.115 rillig *
319 1.149 rillig * Work around the former problem by giving lexi() a copy of the current
320 1.149 rillig * parser state and discard it if the call turned out to be just a
321 1.149 rillig * lookahead.
322 1.115 rillig *
323 1.115 rillig * Work around the latter problem by copying all whitespace characters
324 1.115 rillig * into the buffer so that the later lexi() call will read them.
325 1.91 rillig */
326 1.115 rillig if (sc_end != NULL) {
327 1.124 rillig while (is_hspace(*inp.s)) {
328 1.124 rillig *sc_end++ = *inp.s++;
329 1.115 rillig if (sc_end >= &save_com[sc_size])
330 1.115 rillig errx(1, "input too long");
331 1.91 rillig }
332 1.124 rillig if (inp.s >= inp.e)
333 1.133 rillig inbuf_read_line();
334 1.115 rillig }
335 1.91 rillig
336 1.161 rillig struct parser_state transient_state = ps;
337 1.156 rillig *lsym = lexi(&transient_state); /* read another token */
338 1.156 rillig if (*lsym != lsym_newline && *lsym != lsym_form_feed &&
339 1.158 rillig *lsym != lsym_comment && !transient_state.search_stmt) {
340 1.115 rillig ps = transient_state;
341 1.91 rillig }
342 1.91 rillig }
343 1.91 rillig
344 1.164 rillig /*
345 1.164 rillig * Move newlines and comments following an 'if (expr)', 'while (expr)',
346 1.164 rillig * 'else', etc. up to the start of the following statement to a buffer. This
347 1.164 rillig * allows proper handling of both kinds of brace placement (-br, -bl) and
348 1.164 rillig * "cuddling else" (-ce).
349 1.164 rillig */
350 1.91 rillig static void
351 1.158 rillig search_stmt(lexer_symbol *lsym, bool *force_nl,
352 1.104 rillig bool *comment_buffered, bool *last_else)
353 1.41 rillig {
354 1.158 rillig while (ps.search_stmt) {
355 1.156 rillig switch (*lsym) {
356 1.156 rillig case lsym_newline:
357 1.158 rillig search_stmt_newline(force_nl);
358 1.59 rillig break;
359 1.156 rillig case lsym_form_feed:
360 1.41 rillig break;
361 1.156 rillig case lsym_comment:
362 1.158 rillig search_stmt_comment(comment_buffered);
363 1.41 rillig break;
364 1.156 rillig case lsym_lbrace:
365 1.158 rillig if (search_stmt_lbrace())
366 1.115 rillig goto switch_buffer;
367 1.41 rillig /* FALLTHROUGH */
368 1.41 rillig default: /* it is the start of a normal statement */
369 1.158 rillig if (!search_stmt_other(*lsym, force_nl,
370 1.104 rillig *comment_buffered, *last_else))
371 1.41 rillig return;
372 1.149 rillig switch_buffer:
373 1.91 rillig switch_buffer();
374 1.41 rillig }
375 1.158 rillig search_stmt_lookahead(lsym);
376 1.41 rillig }
377 1.40 rillig
378 1.104 rillig *last_else = false;
379 1.41 rillig }
380 1.1 cgd
381 1.53 rillig static void
382 1.72 rillig buf_init(struct buffer *buf)
383 1.72 rillig {
384 1.123 rillig size_t size = 200;
385 1.123 rillig buf->buf = xmalloc(size);
386 1.86 rillig buf->buf[0] = ' '; /* allow accessing buf->e[-1] */
387 1.72 rillig buf->buf[1] = '\0';
388 1.72 rillig buf->s = buf->buf + 1;
389 1.72 rillig buf->e = buf->s;
390 1.123 rillig buf->l = buf->buf + size - 5; /* safety margin */
391 1.72 rillig }
392 1.72 rillig
393 1.110 rillig static size_t
394 1.110 rillig buf_len(const struct buffer *buf)
395 1.110 rillig {
396 1.110 rillig return (size_t)(buf->e - buf->s);
397 1.110 rillig }
398 1.110 rillig
399 1.81 rillig void
400 1.81 rillig buf_expand(struct buffer *buf, size_t desired_size)
401 1.81 rillig {
402 1.110 rillig size_t nsize = (size_t)(buf->l - buf->s) + 400 + desired_size;
403 1.110 rillig size_t len = buf_len(buf);
404 1.81 rillig buf->buf = xrealloc(buf->buf, nsize);
405 1.110 rillig buf->e = buf->buf + len + 1;
406 1.81 rillig buf->l = buf->buf + nsize - 5;
407 1.81 rillig buf->s = buf->buf + 1;
408 1.81 rillig }
409 1.81 rillig
410 1.72 rillig static void
411 1.112 rillig buf_reserve(struct buffer *buf, size_t n)
412 1.112 rillig {
413 1.112 rillig if (buf->e + n >= buf->l)
414 1.112 rillig buf_expand(buf, n);
415 1.112 rillig }
416 1.112 rillig
417 1.112 rillig static void
418 1.112 rillig buf_add_char(struct buffer *buf, char ch)
419 1.112 rillig {
420 1.112 rillig buf_reserve(buf, 1);
421 1.112 rillig *buf->e++ = ch;
422 1.112 rillig }
423 1.112 rillig
424 1.112 rillig static void
425 1.112 rillig buf_add_buf(struct buffer *buf, const struct buffer *add)
426 1.112 rillig {
427 1.112 rillig size_t len = buf_len(add);
428 1.112 rillig buf_reserve(buf, len);
429 1.112 rillig memcpy(buf->e, add->s, len);
430 1.112 rillig buf->e += len;
431 1.112 rillig }
432 1.112 rillig
433 1.112 rillig static void
434 1.112 rillig buf_terminate(struct buffer *buf)
435 1.112 rillig {
436 1.112 rillig buf_reserve(buf, 1);
437 1.112 rillig *buf->e = '\0';
438 1.112 rillig }
439 1.112 rillig
440 1.112 rillig static void
441 1.112 rillig buf_reset(struct buffer *buf)
442 1.112 rillig {
443 1.112 rillig buf->e = buf->s;
444 1.112 rillig }
445 1.112 rillig
446 1.112 rillig static void
447 1.53 rillig main_init_globals(void)
448 1.40 rillig {
449 1.83 rillig found_err = false;
450 1.1 cgd
451 1.156 rillig ps.s_sym[0] = psym_stmt;
452 1.116 rillig ps.last_nl = true;
453 1.156 rillig ps.last_token = lsym_semicolon;
454 1.72 rillig buf_init(&com);
455 1.72 rillig buf_init(&lab);
456 1.72 rillig buf_init(&code);
457 1.72 rillig buf_init(&token);
458 1.119 rillig
459 1.73 rillig opt.else_if = true; /* XXX: redundant? */
460 1.25 kamil
461 1.124 rillig inp.buf = xmalloc(10);
462 1.124 rillig inp.l = inp.buf + 8;
463 1.124 rillig inp.s = inp.e = inp.buf;
464 1.25 kamil line_no = 1;
465 1.121 rillig had_eof = ps.in_decl = ps.decl_on_line = break_comma = false;
466 1.119 rillig
467 1.134 rillig ps.init_or_struct = false;
468 1.25 kamil ps.want_blank = ps.in_stmt = ps.ind_stmt = false;
469 1.119 rillig ps.is_case_label = false;
470 1.25 kamil
471 1.25 kamil sc_end = NULL;
472 1.125 rillig saved_inp_s = NULL;
473 1.125 rillig saved_inp_e = NULL;
474 1.25 kamil
475 1.25 kamil output = NULL;
476 1.25 kamil
477 1.53 rillig const char *suffix = getenv("SIMPLE_BACKUP_SUFFIX");
478 1.53 rillig if (suffix != NULL)
479 1.88 rillig backup_suffix = suffix;
480 1.53 rillig }
481 1.53 rillig
482 1.131 rillig /*
483 1.131 rillig * Copy the input file to the backup file, then make the backup file the input
484 1.131 rillig * and the original input file the output.
485 1.131 rillig */
486 1.131 rillig static void
487 1.131 rillig bakcopy(void)
488 1.131 rillig {
489 1.131 rillig ssize_t n;
490 1.131 rillig int bak_fd;
491 1.131 rillig char buff[8 * 1024];
492 1.131 rillig
493 1.131 rillig const char *last_slash = strrchr(in_name, '/');
494 1.131 rillig snprintf(bakfile, sizeof(bakfile), "%s%s",
495 1.149 rillig last_slash != NULL ? last_slash + 1 : in_name, backup_suffix);
496 1.131 rillig
497 1.131 rillig /* copy in_name to backup file */
498 1.131 rillig bak_fd = creat(bakfile, 0600);
499 1.131 rillig if (bak_fd < 0)
500 1.131 rillig err(1, "%s", bakfile);
501 1.131 rillig
502 1.131 rillig while ((n = read(fileno(input), buff, sizeof(buff))) > 0)
503 1.131 rillig if (write(bak_fd, buff, (size_t)n) != n)
504 1.131 rillig err(1, "%s", bakfile);
505 1.131 rillig if (n < 0)
506 1.131 rillig err(1, "%s", in_name);
507 1.131 rillig
508 1.131 rillig close(bak_fd);
509 1.131 rillig (void)fclose(input);
510 1.131 rillig
511 1.131 rillig /* re-open backup file as the input file */
512 1.131 rillig input = fopen(bakfile, "r");
513 1.131 rillig if (input == NULL)
514 1.131 rillig err(1, "%s", bakfile);
515 1.131 rillig /* now the original input file will be the output */
516 1.131 rillig output = fopen(in_name, "w");
517 1.131 rillig if (output == NULL) {
518 1.131 rillig unlink(bakfile);
519 1.131 rillig err(1, "%s", in_name);
520 1.131 rillig }
521 1.131 rillig }
522 1.131 rillig
523 1.53 rillig static void
524 1.53 rillig main_parse_command_line(int argc, char **argv)
525 1.53 rillig {
526 1.53 rillig int i;
527 1.53 rillig const char *profile_name = NULL;
528 1.1 cgd
529 1.25 kamil for (i = 1; i < argc; ++i)
530 1.25 kamil if (strcmp(argv[i], "-npro") == 0)
531 1.25 kamil break;
532 1.25 kamil else if (argv[i][0] == '-' && argv[i][1] == 'P' && argv[i][2] != '\0')
533 1.97 rillig profile_name = argv[i] + 2; /* non-empty -P (set profile) */
534 1.25 kamil if (i >= argc)
535 1.98 rillig load_profiles(profile_name);
536 1.1 cgd
537 1.25 kamil for (i = 1; i < argc; ++i) {
538 1.80 rillig if (argv[i][0] == '-') {
539 1.114 rillig set_option(argv[i], "Command line");
540 1.80 rillig
541 1.80 rillig } else if (input == NULL) {
542 1.80 rillig in_name = argv[i];
543 1.80 rillig input = fopen(in_name, "r");
544 1.80 rillig if (input == NULL)
545 1.80 rillig err(1, "%s", in_name);
546 1.80 rillig
547 1.80 rillig } else if (output == NULL) {
548 1.80 rillig out_name = argv[i];
549 1.80 rillig if (strcmp(in_name, out_name) == 0)
550 1.80 rillig errx(1, "input and output files must be different");
551 1.80 rillig output = fopen(out_name, "w");
552 1.80 rillig if (output == NULL)
553 1.80 rillig err(1, "%s", out_name);
554 1.1 cgd
555 1.80 rillig } else
556 1.163 rillig errx(1, "too many arguments: %s", argv[i]);
557 1.80 rillig }
558 1.80 rillig
559 1.25 kamil if (input == NULL)
560 1.25 kamil input = stdin;
561 1.25 kamil if (output == NULL) {
562 1.25 kamil if (input == stdin)
563 1.25 kamil output = stdout;
564 1.25 kamil else {
565 1.25 kamil out_name = in_name;
566 1.25 kamil bakcopy();
567 1.1 cgd }
568 1.25 kamil }
569 1.25 kamil
570 1.57 rillig if (opt.comment_column <= 1)
571 1.57 rillig opt.comment_column = 2; /* don't put normal comments before column 2 */
572 1.51 rillig if (opt.block_comment_max_line_length <= 0)
573 1.51 rillig opt.block_comment_max_line_length = opt.max_line_length;
574 1.100 rillig if (opt.local_decl_indent < 0) /* if not specified by user, set this */
575 1.25 kamil opt.local_decl_indent = opt.decl_indent;
576 1.57 rillig if (opt.decl_comment_column <= 0) /* if not specified by user, set this */
577 1.57 rillig opt.decl_comment_column = opt.ljust_decl
578 1.57 rillig ? (opt.comment_column <= 10 ? 2 : opt.comment_column - 8)
579 1.57 rillig : opt.comment_column;
580 1.25 kamil if (opt.continuation_indent == 0)
581 1.57 rillig opt.continuation_indent = opt.indent_size;
582 1.53 rillig }
583 1.53 rillig
584 1.53 rillig static void
585 1.53 rillig main_prepare_parsing(void)
586 1.53 rillig {
587 1.133 rillig inbuf_read_line();
588 1.25 kamil
589 1.156 rillig parse(psym_semicolon);
590 1.53 rillig
591 1.106 rillig int ind = 0;
592 1.137 rillig for (const char *p = inp.s;; p++) {
593 1.53 rillig if (*p == ' ')
594 1.106 rillig ind++;
595 1.53 rillig else if (*p == '\t')
596 1.136 rillig ind = next_tab(ind);
597 1.53 rillig else
598 1.53 rillig break;
599 1.25 kamil }
600 1.137 rillig
601 1.106 rillig if (ind >= opt.indent_size)
602 1.107 rillig ps.ind_level = ps.ind_level_follow = ind / opt.indent_size;
603 1.53 rillig }
604 1.25 kamil
605 1.131 rillig static void
606 1.131 rillig indent_declaration(int cur_decl_ind, bool tabs_to_var)
607 1.131 rillig {
608 1.137 rillig int ind = (int)buf_len(&code);
609 1.131 rillig char *orig_code_e = code.e;
610 1.131 rillig
611 1.131 rillig /*
612 1.131 rillig * get the tab math right for indentations that are not multiples of
613 1.131 rillig * tabsize
614 1.131 rillig */
615 1.131 rillig if ((ps.ind_level * opt.indent_size) % opt.tabsize != 0) {
616 1.137 rillig ind += (ps.ind_level * opt.indent_size) % opt.tabsize;
617 1.131 rillig cur_decl_ind += (ps.ind_level * opt.indent_size) % opt.tabsize;
618 1.131 rillig }
619 1.131 rillig
620 1.131 rillig if (tabs_to_var) {
621 1.137 rillig for (int next; (next = next_tab(ind)) <= cur_decl_ind; ind = next)
622 1.131 rillig buf_add_char(&code, '\t');
623 1.131 rillig }
624 1.131 rillig
625 1.137 rillig for (; ind < cur_decl_ind; ind++)
626 1.131 rillig buf_add_char(&code, ' ');
627 1.131 rillig
628 1.131 rillig if (code.e == orig_code_e && ps.want_blank) {
629 1.131 rillig *code.e++ = ' ';
630 1.131 rillig ps.want_blank = false;
631 1.131 rillig }
632 1.131 rillig }
633 1.131 rillig
634 1.60 rillig static void __attribute__((__noreturn__))
635 1.54 rillig process_end_of_file(void)
636 1.54 rillig {
637 1.65 rillig if (lab.s != lab.e || code.s != code.e || com.s != com.e)
638 1.54 rillig dump_line();
639 1.54 rillig
640 1.54 rillig if (ps.tos > 1) /* check for balanced braces */
641 1.54 rillig diag(1, "Stuff missing from end of file");
642 1.54 rillig
643 1.54 rillig if (opt.verbose) {
644 1.54 rillig printf("There were %d output lines and %d comments\n",
645 1.86 rillig ps.stats.lines, ps.stats.comments);
646 1.54 rillig printf("(Lines with comments)/(Lines with code): %6.3f\n",
647 1.86 rillig (1.0 * ps.stats.comment_lines) / ps.stats.code_lines);
648 1.54 rillig }
649 1.54 rillig
650 1.54 rillig fflush(output);
651 1.83 rillig exit(found_err ? EXIT_FAILURE : EXIT_SUCCESS);
652 1.54 rillig }
653 1.54 rillig
654 1.54 rillig static void
655 1.156 rillig process_comment_in_code(lexer_symbol lsym, bool *force_nl)
656 1.54 rillig {
657 1.104 rillig if (*force_nl &&
658 1.156 rillig lsym != lsym_semicolon &&
659 1.156 rillig (lsym != lsym_lbrace || !opt.brace_same_line)) {
660 1.54 rillig
661 1.54 rillig /* we should force a broken line here */
662 1.54 rillig if (opt.verbose)
663 1.54 rillig diag(0, "Line broken");
664 1.54 rillig dump_line();
665 1.102 rillig ps.want_blank = false; /* don't insert blank at line start */
666 1.104 rillig *force_nl = false;
667 1.54 rillig }
668 1.54 rillig
669 1.118 rillig /* add an extra level of indentation; turned off again by a ';' or '}' */
670 1.118 rillig ps.in_stmt = true;
671 1.118 rillig
672 1.118 rillig if (com.s != com.e) { /* a comment embedded in a line */
673 1.112 rillig buf_add_char(&code, ' ');
674 1.112 rillig buf_add_buf(&code, &com);
675 1.112 rillig buf_add_char(&code, ' ');
676 1.112 rillig buf_terminate(&code);
677 1.112 rillig buf_reset(&com);
678 1.54 rillig ps.want_blank = false;
679 1.54 rillig }
680 1.54 rillig }
681 1.54 rillig
682 1.54 rillig static void
683 1.54 rillig process_form_feed(void)
684 1.54 rillig {
685 1.145 rillig dump_line_ff();
686 1.54 rillig ps.want_blank = false;
687 1.54 rillig }
688 1.54 rillig
689 1.54 rillig static void
690 1.54 rillig process_newline(void)
691 1.54 rillig {
692 1.156 rillig if (ps.last_token == lsym_comma && ps.p_l_follow == 0 && !ps.block_init &&
693 1.141 rillig !opt.break_after_comma && break_comma &&
694 1.141 rillig com.s == com.e)
695 1.141 rillig goto stay_in_line;
696 1.141 rillig
697 1.141 rillig dump_line();
698 1.141 rillig ps.want_blank = false;
699 1.141 rillig
700 1.141 rillig stay_in_line:
701 1.116 rillig ++line_no;
702 1.54 rillig }
703 1.54 rillig
704 1.94 rillig static bool
705 1.94 rillig want_blank_before_lparen(void)
706 1.94 rillig {
707 1.95 rillig if (!ps.want_blank)
708 1.95 rillig return false;
709 1.156 rillig if (ps.last_token == lsym_rparen_or_rbracket)
710 1.96 rillig return false;
711 1.156 rillig if (ps.last_token != lsym_ident && ps.last_token != lsym_funcname)
712 1.95 rillig return true;
713 1.95 rillig if (opt.proc_calls_space)
714 1.95 rillig return true;
715 1.161 rillig if (ps.prev_keyword == kw_sizeof)
716 1.95 rillig return opt.blank_after_sizeof;
717 1.161 rillig return ps.prev_keyword != kw_0 && ps.prev_keyword != kw_offsetof;
718 1.94 rillig }
719 1.94 rillig
720 1.54 rillig static void
721 1.157 rillig process_lparen_or_lbracket(int decl_ind, bool tabs_to_var, bool spaced_expr)
722 1.54 rillig {
723 1.146 rillig if (++ps.p_l_follow == array_length(ps.paren_indents)) {
724 1.54 rillig diag(0, "Reached internal limit of %zu unclosed parens",
725 1.146 rillig array_length(ps.paren_indents));
726 1.54 rillig ps.p_l_follow--;
727 1.54 rillig }
728 1.119 rillig
729 1.93 rillig if (token.s[0] == '(' && ps.in_decl
730 1.93 rillig && !ps.block_init && !ps.dumped_decl_indent &&
731 1.54 rillig ps.procname[0] == '\0' && ps.paren_level == 0) {
732 1.54 rillig /* function pointer declarations */
733 1.105 rillig indent_declaration(decl_ind, tabs_to_var);
734 1.54 rillig ps.dumped_decl_indent = true;
735 1.94 rillig } else if (want_blank_before_lparen())
736 1.65 rillig *code.e++ = ' ';
737 1.54 rillig ps.want_blank = false;
738 1.67 rillig *code.e++ = token.s[0];
739 1.58 rillig
740 1.54 rillig ps.paren_indents[ps.p_l_follow - 1] =
741 1.103 rillig (short)indentation_after_range(0, code.s, code.e);
742 1.135 rillig debug_println("paren_indents[%d] is now %d",
743 1.58 rillig ps.p_l_follow - 1, ps.paren_indents[ps.p_l_follow - 1]);
744 1.58 rillig
745 1.157 rillig if (spaced_expr && ps.p_l_follow == 1 && opt.extra_expr_indent
746 1.58 rillig && ps.paren_indents[0] < 2 * opt.indent_size) {
747 1.103 rillig ps.paren_indents[0] = (short)(2 * opt.indent_size);
748 1.135 rillig debug_println("paren_indents[0] is now %d", ps.paren_indents[0]);
749 1.58 rillig }
750 1.119 rillig
751 1.134 rillig if (ps.init_or_struct && *token.s == '(' && ps.tos <= 2) {
752 1.54 rillig /*
753 1.86 rillig * this is a kluge to make sure that declarations will be aligned
754 1.86 rillig * right if proc decl has an explicit type on it, i.e. "int a(x) {..."
755 1.54 rillig */
756 1.156 rillig parse(psym_semicolon); /* I said this was a kluge... */
757 1.134 rillig ps.init_or_struct = false;
758 1.54 rillig }
759 1.119 rillig
760 1.54 rillig /* parenthesized type following sizeof or offsetof is not a cast */
761 1.161 rillig if (ps.prev_keyword == kw_offsetof || ps.prev_keyword == kw_sizeof)
762 1.54 rillig ps.not_cast_mask |= 1 << ps.p_l_follow;
763 1.54 rillig }
764 1.54 rillig
765 1.54 rillig static void
766 1.157 rillig process_rparen_or_rbracket(bool *spaced_expr, bool *force_nl, stmt_head hd)
767 1.54 rillig {
768 1.73 rillig if ((ps.cast_mask & (1 << ps.p_l_follow) & ~ps.not_cast_mask) != 0) {
769 1.144 rillig ps.next_unary = true;
770 1.54 rillig ps.cast_mask &= (1 << ps.p_l_follow) - 1;
771 1.54 rillig ps.want_blank = opt.space_after_cast;
772 1.54 rillig } else
773 1.54 rillig ps.want_blank = true;
774 1.54 rillig ps.not_cast_mask &= (1 << ps.p_l_follow) - 1;
775 1.54 rillig
776 1.54 rillig if (--ps.p_l_follow < 0) {
777 1.54 rillig ps.p_l_follow = 0;
778 1.67 rillig diag(0, "Extra %c", *token.s);
779 1.54 rillig }
780 1.54 rillig
781 1.65 rillig if (code.e == code.s) /* if the paren starts the line */
782 1.54 rillig ps.paren_level = ps.p_l_follow; /* then indent it */
783 1.54 rillig
784 1.67 rillig *code.e++ = token.s[0];
785 1.54 rillig
786 1.157 rillig if (*spaced_expr && ps.p_l_follow == 0) { /* check for end of 'if
787 1.157 rillig * (...)', or some such */
788 1.157 rillig *spaced_expr = false;
789 1.104 rillig *force_nl = true; /* must force newline after if */
790 1.144 rillig ps.next_unary = true;
791 1.102 rillig ps.in_stmt = false; /* don't use stmt continuation indentation */
792 1.54 rillig
793 1.156 rillig parse_hd(hd); /* let parser worry about if, or whatever */
794 1.54 rillig }
795 1.122 rillig
796 1.122 rillig /*
797 1.122 rillig * This should ensure that constructs such as main(){...} and int[]{...}
798 1.122 rillig * have their braces put in the right place.
799 1.122 rillig */
800 1.158 rillig ps.search_stmt = opt.brace_same_line;
801 1.54 rillig }
802 1.54 rillig
803 1.54 rillig static void
804 1.105 rillig process_unary_op(int decl_ind, bool tabs_to_var)
805 1.54 rillig {
806 1.54 rillig if (!ps.dumped_decl_indent && ps.in_decl && !ps.block_init &&
807 1.54 rillig ps.procname[0] == '\0' && ps.paren_level == 0) {
808 1.54 rillig /* pointer declarations */
809 1.132 rillig indent_declaration(decl_ind - (int)buf_len(&token), tabs_to_var);
810 1.54 rillig ps.dumped_decl_indent = true;
811 1.54 rillig } else if (ps.want_blank)
812 1.65 rillig *code.e++ = ' ';
813 1.54 rillig
814 1.112 rillig buf_add_buf(&code, &token);
815 1.54 rillig ps.want_blank = false;
816 1.54 rillig }
817 1.54 rillig
818 1.54 rillig static void
819 1.54 rillig process_binary_op(void)
820 1.54 rillig {
821 1.54 rillig if (ps.want_blank)
822 1.112 rillig buf_add_char(&code, ' ');
823 1.112 rillig buf_add_buf(&code, &token);
824 1.54 rillig ps.want_blank = true;
825 1.54 rillig }
826 1.54 rillig
827 1.54 rillig static void
828 1.54 rillig process_postfix_op(void)
829 1.54 rillig {
830 1.67 rillig *code.e++ = token.s[0];
831 1.67 rillig *code.e++ = token.s[1];
832 1.54 rillig ps.want_blank = true;
833 1.54 rillig }
834 1.54 rillig
835 1.54 rillig static void
836 1.152 rillig process_question(int *quest_level)
837 1.54 rillig {
838 1.152 rillig (*quest_level)++;
839 1.54 rillig if (ps.want_blank)
840 1.65 rillig *code.e++ = ' ';
841 1.65 rillig *code.e++ = '?';
842 1.54 rillig ps.want_blank = true;
843 1.54 rillig }
844 1.54 rillig
845 1.54 rillig static void
846 1.152 rillig process_colon(int *quest_level, bool *force_nl, bool *seen_case)
847 1.54 rillig {
848 1.152 rillig if (*quest_level > 0) { /* part of a '?:' operator */
849 1.152 rillig --*quest_level;
850 1.54 rillig if (ps.want_blank)
851 1.65 rillig *code.e++ = ' ';
852 1.65 rillig *code.e++ = ':';
853 1.54 rillig ps.want_blank = true;
854 1.54 rillig return;
855 1.54 rillig }
856 1.113 rillig
857 1.149 rillig if (ps.init_or_struct) { /* bit-field */
858 1.65 rillig *code.e++ = ':';
859 1.54 rillig ps.want_blank = false;
860 1.54 rillig return;
861 1.54 rillig }
862 1.54 rillig
863 1.113 rillig buf_add_buf(&lab, &code); /* 'case' or 'default' or named label */
864 1.112 rillig buf_add_char(&lab, ':');
865 1.112 rillig buf_terminate(&lab);
866 1.112 rillig buf_reset(&code);
867 1.112 rillig
868 1.113 rillig ps.in_stmt = false;
869 1.113 rillig ps.is_case_label = *seen_case;
870 1.113 rillig *force_nl = *seen_case;
871 1.105 rillig *seen_case = false;
872 1.54 rillig ps.want_blank = false;
873 1.54 rillig }
874 1.54 rillig
875 1.54 rillig static void
876 1.152 rillig process_semicolon(bool *seen_case, int *quest_level, int decl_ind,
877 1.157 rillig bool tabs_to_var, bool *spaced_expr, stmt_head hd, bool *force_nl)
878 1.54 rillig {
879 1.79 rillig if (ps.decl_nest == 0)
880 1.135 rillig ps.init_or_struct = false;
881 1.105 rillig *seen_case = false; /* these will only need resetting in an error */
882 1.152 rillig *quest_level = 0;
883 1.156 rillig if (ps.last_token == lsym_rparen_or_rbracket)
884 1.73 rillig ps.in_parameter_declaration = false;
885 1.54 rillig ps.cast_mask = 0;
886 1.54 rillig ps.not_cast_mask = 0;
887 1.73 rillig ps.block_init = false;
888 1.54 rillig ps.block_init_level = 0;
889 1.54 rillig ps.just_saw_decl--;
890 1.54 rillig
891 1.65 rillig if (ps.in_decl && code.s == code.e && !ps.block_init &&
892 1.54 rillig !ps.dumped_decl_indent && ps.paren_level == 0) {
893 1.54 rillig /* indent stray semicolons in declarations */
894 1.105 rillig indent_declaration(decl_ind - 1, tabs_to_var);
895 1.54 rillig ps.dumped_decl_indent = true;
896 1.54 rillig }
897 1.54 rillig
898 1.135 rillig ps.in_decl = ps.decl_nest > 0; /* if we were in a first level
899 1.102 rillig * structure declaration, we aren't
900 1.102 rillig * anymore */
901 1.54 rillig
902 1.157 rillig if ((!*spaced_expr || hd != hd_for) && ps.p_l_follow > 0) {
903 1.54 rillig
904 1.54 rillig /*
905 1.135 rillig * There were unbalanced parens in the statement. It is a bit
906 1.135 rillig * complicated, because the semicolon might be in a for statement.
907 1.54 rillig */
908 1.54 rillig diag(1, "Unbalanced parens");
909 1.54 rillig ps.p_l_follow = 0;
910 1.157 rillig if (*spaced_expr) { /* 'if', 'while', etc. with unbalanced
911 1.157 rillig * parentheses */
912 1.157 rillig *spaced_expr = false;
913 1.156 rillig parse_hd(hd); /* don't lose the 'if', or whatever */
914 1.54 rillig }
915 1.54 rillig }
916 1.65 rillig *code.e++ = ';';
917 1.54 rillig ps.want_blank = true;
918 1.157 rillig ps.in_stmt = ps.p_l_follow > 0; /* we are no longer in the middle of a
919 1.86 rillig * stmt */
920 1.54 rillig
921 1.157 rillig if (!*spaced_expr) { /* if not if for (;;) */
922 1.156 rillig parse(psym_semicolon); /* let parser know about end of stmt */
923 1.104 rillig *force_nl = true; /* force newline after an end of stmt */
924 1.54 rillig }
925 1.54 rillig }
926 1.54 rillig
927 1.54 rillig static void
928 1.157 rillig process_lbrace(bool *force_nl, bool *spaced_expr, stmt_head hd,
929 1.105 rillig int *di_stack, int di_stack_cap, int *decl_ind)
930 1.54 rillig {
931 1.102 rillig ps.in_stmt = false; /* don't indent the {} */
932 1.119 rillig
933 1.54 rillig if (!ps.block_init)
934 1.104 rillig *force_nl = true; /* force other stuff on same line as '{' onto
935 1.54 rillig * new line */
936 1.54 rillig else if (ps.block_init_level <= 0)
937 1.54 rillig ps.block_init_level = 1;
938 1.54 rillig else
939 1.54 rillig ps.block_init_level++;
940 1.54 rillig
941 1.65 rillig if (code.s != code.e && !ps.block_init) {
942 1.122 rillig if (!opt.brace_same_line) {
943 1.54 rillig dump_line();
944 1.54 rillig ps.want_blank = false;
945 1.134 rillig } else if (ps.in_parameter_declaration && !ps.init_or_struct) {
946 1.79 rillig ps.ind_level_follow = 0;
947 1.86 rillig if (opt.function_brace_split) { /* dump the line prior to the
948 1.86 rillig * brace ... */
949 1.54 rillig dump_line();
950 1.54 rillig ps.want_blank = false;
951 1.54 rillig } else /* add a space between the decl and brace */
952 1.54 rillig ps.want_blank = true;
953 1.54 rillig }
954 1.54 rillig }
955 1.119 rillig
956 1.54 rillig if (ps.in_parameter_declaration)
957 1.142 rillig blank_line_before = false;
958 1.54 rillig
959 1.86 rillig if (ps.p_l_follow > 0) { /* check for preceding unbalanced parens */
960 1.54 rillig diag(1, "Unbalanced parens");
961 1.54 rillig ps.p_l_follow = 0;
962 1.157 rillig if (*spaced_expr) { /* check for unclosed 'if', 'for', etc. */
963 1.157 rillig *spaced_expr = false;
964 1.156 rillig parse_hd(hd);
965 1.79 rillig ps.ind_level = ps.ind_level_follow;
966 1.54 rillig }
967 1.54 rillig }
968 1.119 rillig
969 1.65 rillig if (code.s == code.e)
970 1.118 rillig ps.ind_stmt = false; /* don't indent the '{' itself */
971 1.134 rillig if (ps.in_decl && ps.init_or_struct) {
972 1.105 rillig di_stack[ps.decl_nest] = *decl_ind;
973 1.79 rillig if (++ps.decl_nest == di_stack_cap) {
974 1.54 rillig diag(0, "Reached internal limit of %d struct levels",
975 1.86 rillig di_stack_cap);
976 1.79 rillig ps.decl_nest--;
977 1.54 rillig }
978 1.54 rillig } else {
979 1.86 rillig ps.decl_on_line = false; /* we can't be in the middle of a
980 1.86 rillig * declaration, so don't do special
981 1.86 rillig * indentation of comments */
982 1.128 rillig if (opt.blanklines_after_decl_at_top && ps.in_parameter_declaration)
983 1.142 rillig blank_line_after = true;
984 1.73 rillig ps.in_parameter_declaration = false;
985 1.54 rillig ps.in_decl = false;
986 1.54 rillig }
987 1.119 rillig
988 1.105 rillig *decl_ind = 0;
989 1.156 rillig parse(psym_lbrace);
990 1.116 rillig if (ps.want_blank)
991 1.65 rillig *code.e++ = ' ';
992 1.54 rillig ps.want_blank = false;
993 1.65 rillig *code.e++ = '{';
994 1.54 rillig ps.just_saw_decl = 0;
995 1.54 rillig }
996 1.54 rillig
997 1.54 rillig static void
998 1.157 rillig process_rbrace(bool *spaced_expr, int *decl_ind, const int *di_stack)
999 1.54 rillig {
1000 1.156 rillig if (ps.s_sym[ps.tos] == psym_decl && !ps.block_init) {
1001 1.156 rillig /* semicolons can be omitted in declarations */
1002 1.156 rillig parse(psym_semicolon);
1003 1.156 rillig }
1004 1.119 rillig
1005 1.73 rillig if (ps.p_l_follow != 0) { /* check for unclosed if, for, else. */
1006 1.54 rillig diag(1, "Unbalanced parens");
1007 1.54 rillig ps.p_l_follow = 0;
1008 1.157 rillig *spaced_expr = false;
1009 1.54 rillig }
1010 1.119 rillig
1011 1.54 rillig ps.just_saw_decl = 0;
1012 1.54 rillig ps.block_init_level--;
1013 1.119 rillig
1014 1.65 rillig if (code.s != code.e && !ps.block_init) { /* '}' must be first on line */
1015 1.54 rillig if (opt.verbose)
1016 1.54 rillig diag(0, "Line broken");
1017 1.54 rillig dump_line();
1018 1.54 rillig }
1019 1.119 rillig
1020 1.65 rillig *code.e++ = '}';
1021 1.54 rillig ps.want_blank = true;
1022 1.54 rillig ps.in_stmt = ps.ind_stmt = false;
1023 1.119 rillig
1024 1.79 rillig if (ps.decl_nest > 0) { /* we are in multi-level structure declaration */
1025 1.105 rillig *decl_ind = di_stack[--ps.decl_nest];
1026 1.151 rillig if (ps.decl_nest == 0 && !ps.in_parameter_declaration) {
1027 1.54 rillig ps.just_saw_decl = 2;
1028 1.151 rillig *decl_ind = ps.ind_level == 0
1029 1.151 rillig ? opt.decl_indent : opt.local_decl_indent;
1030 1.151 rillig }
1031 1.54 rillig ps.in_decl = true;
1032 1.54 rillig }
1033 1.119 rillig
1034 1.142 rillig blank_line_before = false;
1035 1.156 rillig parse(psym_rbrace);
1036 1.158 rillig ps.search_stmt = opt.cuddle_else
1037 1.156 rillig && ps.s_sym[ps.tos] == psym_if_expr_stmt
1038 1.143 rillig && ps.s_ind_level[ps.tos] >= ps.ind_level;
1039 1.119 rillig
1040 1.79 rillig if (ps.tos <= 1 && opt.blanklines_after_procs && ps.decl_nest <= 0)
1041 1.142 rillig blank_line_after = true;
1042 1.54 rillig }
1043 1.54 rillig
1044 1.54 rillig static void
1045 1.127 rillig process_keyword_do(bool *force_nl, bool *last_else)
1046 1.54 rillig {
1047 1.54 rillig ps.in_stmt = false;
1048 1.119 rillig
1049 1.127 rillig if (code.e != code.s) { /* make sure this starts a line */
1050 1.127 rillig if (opt.verbose)
1051 1.127 rillig diag(0, "Line broken");
1052 1.127 rillig dump_line();
1053 1.127 rillig ps.want_blank = false;
1054 1.127 rillig }
1055 1.119 rillig
1056 1.127 rillig *force_nl = true; /* following stuff must go onto new line */
1057 1.127 rillig *last_else = false;
1058 1.156 rillig parse(psym_do);
1059 1.127 rillig }
1060 1.119 rillig
1061 1.127 rillig static void
1062 1.127 rillig process_keyword_else(bool *force_nl, bool *last_else)
1063 1.127 rillig {
1064 1.127 rillig ps.in_stmt = false;
1065 1.119 rillig
1066 1.127 rillig if (code.e != code.s && (!opt.cuddle_else || code.e[-1] != '}')) {
1067 1.127 rillig if (opt.verbose)
1068 1.127 rillig diag(0, "Line broken");
1069 1.127 rillig dump_line(); /* make sure this starts a line */
1070 1.127 rillig ps.want_blank = false;
1071 1.54 rillig }
1072 1.127 rillig
1073 1.127 rillig *force_nl = true; /* following stuff must go onto new line */
1074 1.127 rillig *last_else = true;
1075 1.156 rillig parse(psym_else);
1076 1.54 rillig }
1077 1.54 rillig
1078 1.54 rillig static void
1079 1.164 rillig process_type(int *decl_ind, bool *tabs_to_var)
1080 1.54 rillig {
1081 1.156 rillig parse(psym_decl); /* let the parser worry about indentation */
1082 1.119 rillig
1083 1.156 rillig if (ps.last_token == lsym_rparen_or_rbracket && ps.tos <= 1) {
1084 1.65 rillig if (code.s != code.e) {
1085 1.54 rillig dump_line();
1086 1.73 rillig ps.want_blank = false;
1087 1.54 rillig }
1088 1.54 rillig }
1089 1.119 rillig
1090 1.79 rillig if (ps.in_parameter_declaration && opt.indent_parameters &&
1091 1.79 rillig ps.decl_nest == 0) {
1092 1.79 rillig ps.ind_level = ps.ind_level_follow = 1;
1093 1.73 rillig ps.ind_stmt = false;
1094 1.54 rillig }
1095 1.119 rillig
1096 1.134 rillig ps.init_or_struct = /* maybe */ true;
1097 1.156 rillig ps.in_decl = ps.decl_on_line = ps.last_token != lsym_typedef;
1098 1.134 rillig if (ps.decl_nest <= 0)
1099 1.54 rillig ps.just_saw_decl = 2;
1100 1.119 rillig
1101 1.142 rillig blank_line_before = false;
1102 1.54 rillig
1103 1.132 rillig int len = (int)buf_len(&token) + 1;
1104 1.82 rillig int ind = ps.ind_level == 0 || ps.decl_nest > 0
1105 1.149 rillig ? opt.decl_indent /* global variable or local member */
1106 1.149 rillig : opt.local_decl_indent; /* local variable */
1107 1.132 rillig *decl_ind = ind > 0 ? ind : len;
1108 1.132 rillig *tabs_to_var = opt.use_tabs && ind > 0;
1109 1.54 rillig }
1110 1.54 rillig
1111 1.54 rillig static void
1112 1.156 rillig process_ident(lexer_symbol lsym, int decl_ind, bool tabs_to_var,
1113 1.157 rillig bool *spaced_expr, bool *force_nl, stmt_head hd)
1114 1.54 rillig {
1115 1.54 rillig if (ps.in_decl) {
1116 1.156 rillig if (lsym == lsym_funcname) {
1117 1.54 rillig ps.in_decl = false;
1118 1.65 rillig if (opt.procnames_start_line && code.s != code.e) {
1119 1.65 rillig *code.e = '\0';
1120 1.54 rillig dump_line();
1121 1.54 rillig } else if (ps.want_blank) {
1122 1.65 rillig *code.e++ = ' ';
1123 1.54 rillig }
1124 1.54 rillig ps.want_blank = false;
1125 1.119 rillig
1126 1.54 rillig } else if (!ps.block_init && !ps.dumped_decl_indent &&
1127 1.86 rillig ps.paren_level == 0) { /* if we are in a declaration, we must
1128 1.86 rillig * indent identifier */
1129 1.105 rillig indent_declaration(decl_ind, tabs_to_var);
1130 1.54 rillig ps.dumped_decl_indent = true;
1131 1.54 rillig ps.want_blank = false;
1132 1.54 rillig }
1133 1.119 rillig
1134 1.157 rillig } else if (*spaced_expr && ps.p_l_follow == 0) {
1135 1.157 rillig *spaced_expr = false;
1136 1.104 rillig *force_nl = true;
1137 1.144 rillig ps.next_unary = true;
1138 1.54 rillig ps.in_stmt = false;
1139 1.156 rillig parse_hd(hd);
1140 1.54 rillig }
1141 1.54 rillig }
1142 1.54 rillig
1143 1.54 rillig static void
1144 1.111 rillig copy_token(void)
1145 1.54 rillig {
1146 1.54 rillig if (ps.want_blank)
1147 1.112 rillig buf_add_char(&code, ' ');
1148 1.112 rillig buf_add_buf(&code, &token);
1149 1.54 rillig }
1150 1.54 rillig
1151 1.54 rillig static void
1152 1.54 rillig process_string_prefix(void)
1153 1.54 rillig {
1154 1.112 rillig copy_token();
1155 1.54 rillig ps.want_blank = false;
1156 1.54 rillig }
1157 1.54 rillig
1158 1.54 rillig static void
1159 1.54 rillig process_period(void)
1160 1.54 rillig {
1161 1.85 rillig if (code.e[-1] == ',')
1162 1.85 rillig *code.e++ = ' ';
1163 1.102 rillig *code.e++ = '.';
1164 1.102 rillig ps.want_blank = false;
1165 1.54 rillig }
1166 1.54 rillig
1167 1.54 rillig static void
1168 1.105 rillig process_comma(int decl_ind, bool tabs_to_var, bool *force_nl)
1169 1.54 rillig {
1170 1.135 rillig ps.want_blank = code.s != code.e; /* only put blank after comma if comma
1171 1.86 rillig * does not start the line */
1172 1.119 rillig
1173 1.54 rillig if (ps.in_decl && ps.procname[0] == '\0' && !ps.block_init &&
1174 1.54 rillig !ps.dumped_decl_indent && ps.paren_level == 0) {
1175 1.54 rillig /* indent leading commas and not the actual identifiers */
1176 1.105 rillig indent_declaration(decl_ind - 1, tabs_to_var);
1177 1.54 rillig ps.dumped_decl_indent = true;
1178 1.54 rillig }
1179 1.119 rillig
1180 1.65 rillig *code.e++ = ',';
1181 1.119 rillig
1182 1.54 rillig if (ps.p_l_follow == 0) {
1183 1.54 rillig if (ps.block_init_level <= 0)
1184 1.73 rillig ps.block_init = false;
1185 1.87 rillig if (break_comma && (opt.break_after_comma ||
1186 1.149 rillig indentation_after_range(compute_code_indent(), code.s, code.e)
1187 1.149 rillig >= opt.max_line_length - opt.tabsize))
1188 1.104 rillig *force_nl = true;
1189 1.54 rillig }
1190 1.54 rillig }
1191 1.54 rillig
1192 1.112 rillig /* move the whole line to the 'label' buffer */
1193 1.54 rillig static void
1194 1.115 rillig read_preprocessing_line(void)
1195 1.54 rillig {
1196 1.129 rillig enum {
1197 1.129 rillig PLAIN, STR, CHR, COMM
1198 1.129 rillig } state;
1199 1.129 rillig
1200 1.112 rillig buf_add_char(&lab, '#');
1201 1.54 rillig
1202 1.129 rillig state = PLAIN;
1203 1.115 rillig int com_start = 0, com_end = 0;
1204 1.115 rillig
1205 1.124 rillig while (is_hspace(*inp.s))
1206 1.115 rillig inbuf_skip();
1207 1.115 rillig
1208 1.129 rillig while (*inp.s != '\n' || (state == COMM && !had_eof)) {
1209 1.115 rillig buf_reserve(&lab, 2);
1210 1.115 rillig *lab.e++ = inbuf_next();
1211 1.115 rillig switch (lab.e[-1]) {
1212 1.115 rillig case '\\':
1213 1.129 rillig if (state != COMM)
1214 1.115 rillig *lab.e++ = inbuf_next();
1215 1.115 rillig break;
1216 1.115 rillig case '/':
1217 1.129 rillig if (*inp.s == '*' && state == PLAIN) {
1218 1.129 rillig state = COMM;
1219 1.124 rillig *lab.e++ = *inp.s++;
1220 1.115 rillig com_start = (int)buf_len(&lab) - 2;
1221 1.115 rillig }
1222 1.115 rillig break;
1223 1.115 rillig case '"':
1224 1.129 rillig if (state == STR)
1225 1.129 rillig state = PLAIN;
1226 1.129 rillig else if (state == PLAIN)
1227 1.129 rillig state = STR;
1228 1.115 rillig break;
1229 1.115 rillig case '\'':
1230 1.129 rillig if (state == CHR)
1231 1.129 rillig state = PLAIN;
1232 1.129 rillig else if (state == PLAIN)
1233 1.129 rillig state = CHR;
1234 1.115 rillig break;
1235 1.115 rillig case '*':
1236 1.129 rillig if (*inp.s == '/' && state == COMM) {
1237 1.129 rillig state = PLAIN;
1238 1.124 rillig *lab.e++ = *inp.s++;
1239 1.115 rillig com_end = (int)buf_len(&lab);
1240 1.54 rillig }
1241 1.115 rillig break;
1242 1.54 rillig }
1243 1.115 rillig }
1244 1.54 rillig
1245 1.115 rillig while (lab.e > lab.s && is_hspace(lab.e[-1]))
1246 1.115 rillig lab.e--;
1247 1.125 rillig if (lab.e - lab.s == com_end && saved_inp_s == NULL) {
1248 1.115 rillig /* comment on preprocessor line */
1249 1.115 rillig if (sc_end == NULL) { /* if this is the first comment, we must set
1250 1.115 rillig * up the buffer */
1251 1.115 rillig save_com = sc_buf;
1252 1.115 rillig sc_end = save_com;
1253 1.115 rillig } else {
1254 1.115 rillig *sc_end++ = '\n'; /* add newline between comments */
1255 1.115 rillig *sc_end++ = ' ';
1256 1.115 rillig --line_no;
1257 1.115 rillig }
1258 1.115 rillig if (sc_end - save_com + com_end - com_start > sc_size)
1259 1.115 rillig errx(1, "input too long");
1260 1.115 rillig memmove(sc_end, lab.s + com_start, (size_t)(com_end - com_start));
1261 1.115 rillig sc_end += com_end - com_start;
1262 1.115 rillig lab.e = lab.s + com_start;
1263 1.101 rillig while (lab.e > lab.s && is_hspace(lab.e[-1]))
1264 1.63 rillig lab.e--;
1265 1.125 rillig saved_inp_s = inp.s; /* save current input buffer */
1266 1.125 rillig saved_inp_e = inp.e;
1267 1.124 rillig inp.s = save_com; /* fix so that subsequent calls to lexi will
1268 1.58 rillig * take tokens out of save_com */
1269 1.115 rillig *sc_end++ = ' '; /* add trailing blank, just in case */
1270 1.124 rillig inp.e = sc_end;
1271 1.115 rillig sc_end = NULL;
1272 1.124 rillig debug_println("switched inp.s to save_com");
1273 1.54 rillig }
1274 1.115 rillig buf_terminate(&lab);
1275 1.115 rillig }
1276 1.115 rillig
1277 1.115 rillig static void
1278 1.115 rillig process_preprocessing(void)
1279 1.115 rillig {
1280 1.115 rillig if (com.s != com.e || lab.s != lab.e || code.s != code.e)
1281 1.115 rillig dump_line();
1282 1.115 rillig
1283 1.115 rillig read_preprocessing_line();
1284 1.115 rillig
1285 1.115 rillig ps.is_case_label = false;
1286 1.54 rillig
1287 1.86 rillig if (strncmp(lab.s, "#if", 3) == 0) { /* also ifdef, ifndef */
1288 1.146 rillig if ((size_t)ifdef_level < array_length(state_stack))
1289 1.54 rillig state_stack[ifdef_level++] = ps;
1290 1.88 rillig else
1291 1.54 rillig diag(1, "#if stack overflow");
1292 1.119 rillig
1293 1.86 rillig } else if (strncmp(lab.s, "#el", 3) == 0) { /* else, elif */
1294 1.54 rillig if (ifdef_level <= 0)
1295 1.63 rillig diag(1, lab.s[3] == 'i' ? "Unmatched #elif" : "Unmatched #else");
1296 1.88 rillig else
1297 1.54 rillig ps = state_stack[ifdef_level - 1];
1298 1.119 rillig
1299 1.63 rillig } else if (strncmp(lab.s, "#endif", 6) == 0) {
1300 1.54 rillig if (ifdef_level <= 0)
1301 1.54 rillig diag(1, "Unmatched #endif");
1302 1.54 rillig else
1303 1.54 rillig ifdef_level--;
1304 1.119 rillig
1305 1.54 rillig } else {
1306 1.63 rillig if (strncmp(lab.s + 1, "pragma", 6) != 0 &&
1307 1.63 rillig strncmp(lab.s + 1, "error", 5) != 0 &&
1308 1.63 rillig strncmp(lab.s + 1, "line", 4) != 0 &&
1309 1.63 rillig strncmp(lab.s + 1, "undef", 5) != 0 &&
1310 1.63 rillig strncmp(lab.s + 1, "define", 6) != 0 &&
1311 1.63 rillig strncmp(lab.s + 1, "include", 7) != 0) {
1312 1.54 rillig diag(1, "Unrecognized cpp directive");
1313 1.54 rillig return;
1314 1.54 rillig }
1315 1.54 rillig }
1316 1.119 rillig
1317 1.54 rillig if (opt.blanklines_around_conditional_compilation) {
1318 1.142 rillig blank_line_after = true;
1319 1.140 rillig blank_lines_to_output = 0;
1320 1.54 rillig } else {
1321 1.142 rillig blank_line_after = false;
1322 1.142 rillig blank_line_before = false;
1323 1.54 rillig }
1324 1.54 rillig
1325 1.54 rillig /*
1326 1.54 rillig * subsequent processing of the newline character will cause the line to
1327 1.54 rillig * be printed
1328 1.54 rillig */
1329 1.54 rillig }
1330 1.54 rillig
1331 1.60 rillig static void __attribute__((__noreturn__))
1332 1.53 rillig main_loop(void)
1333 1.53 rillig {
1334 1.150 rillig bool force_nl = false; /* when true, code must be broken */
1335 1.75 rillig bool last_else = false; /* true iff last keyword was an else */
1336 1.150 rillig int decl_ind = 0; /* current indentation for declarations */
1337 1.86 rillig int di_stack[20]; /* a stack of structure indentation levels */
1338 1.150 rillig bool tabs_to_var = false; /* true if using tabs to indent to var name */
1339 1.157 rillig bool spaced_expr = false; /* whether we are in the expression of
1340 1.53 rillig * if(...), while(...), etc. */
1341 1.160 rillig stmt_head hd = hd_0; /* the type of statement for 'if (...)', 'for
1342 1.160 rillig * (...)', etc */
1343 1.152 rillig int quest_level = 0; /* when this is positive, we have seen a '?'
1344 1.152 rillig * without the matching ':' in a '?:'
1345 1.152 rillig * expression */
1346 1.150 rillig bool seen_case = false; /* set to true when we see a 'case', so we
1347 1.53 rillig * know what to do with the following colon */
1348 1.53 rillig
1349 1.79 rillig di_stack[ps.decl_nest = 0] = 0;
1350 1.1 cgd
1351 1.59 rillig for (;;) { /* this is the main loop. it will go until we
1352 1.1 cgd * reach eof */
1353 1.75 rillig bool comment_buffered = false;
1354 1.1 cgd
1355 1.156 rillig lexer_symbol lsym = lexi(&ps); /* Read the next token. The actual
1356 1.150 rillig * characters read are stored in
1357 1.150 rillig * "token". */
1358 1.1 cgd
1359 1.158 rillig search_stmt(&lsym, &force_nl, &comment_buffered, &last_else);
1360 1.25 kamil
1361 1.156 rillig if (lsym == lsym_eof) {
1362 1.54 rillig process_end_of_file();
1363 1.60 rillig /* NOTREACHED */
1364 1.54 rillig }
1365 1.25 kamil
1366 1.156 rillig if (lsym == lsym_newline || lsym == lsym_form_feed ||
1367 1.156 rillig lsym == lsym_preprocessing)
1368 1.130 rillig force_nl = false;
1369 1.156 rillig else if (lsym != lsym_comment)
1370 1.156 rillig process_comment_in_code(lsym, &force_nl);
1371 1.25 kamil
1372 1.112 rillig buf_reserve(&code, 3); /* space for 2 characters plus '\0' */
1373 1.1 cgd
1374 1.156 rillig switch (lsym) {
1375 1.25 kamil
1376 1.156 rillig case lsym_form_feed:
1377 1.54 rillig process_form_feed();
1378 1.25 kamil break;
1379 1.25 kamil
1380 1.156 rillig case lsym_newline:
1381 1.54 rillig process_newline();
1382 1.25 kamil break;
1383 1.25 kamil
1384 1.156 rillig case lsym_lparen_or_lbracket:
1385 1.157 rillig process_lparen_or_lbracket(decl_ind, tabs_to_var, spaced_expr);
1386 1.25 kamil break;
1387 1.25 kamil
1388 1.156 rillig case lsym_rparen_or_rbracket:
1389 1.157 rillig process_rparen_or_rbracket(&spaced_expr, &force_nl, hd);
1390 1.25 kamil break;
1391 1.25 kamil
1392 1.156 rillig case lsym_unary_op:
1393 1.105 rillig process_unary_op(decl_ind, tabs_to_var);
1394 1.25 kamil break;
1395 1.25 kamil
1396 1.156 rillig case lsym_binary_op:
1397 1.54 rillig process_binary_op();
1398 1.25 kamil break;
1399 1.25 kamil
1400 1.156 rillig case lsym_postfix_op:
1401 1.54 rillig process_postfix_op();
1402 1.25 kamil break;
1403 1.25 kamil
1404 1.156 rillig case lsym_question:
1405 1.152 rillig process_question(&quest_level);
1406 1.25 kamil break;
1407 1.25 kamil
1408 1.164 rillig case lsym_case_label:
1409 1.116 rillig seen_case = true;
1410 1.111 rillig goto copy_token;
1411 1.25 kamil
1412 1.156 rillig case lsym_colon:
1413 1.152 rillig process_colon(&quest_level, &force_nl, &seen_case);
1414 1.25 kamil break;
1415 1.25 kamil
1416 1.156 rillig case lsym_semicolon:
1417 1.152 rillig process_semicolon(&seen_case, &quest_level, decl_ind, tabs_to_var,
1418 1.157 rillig &spaced_expr, hd, &force_nl);
1419 1.25 kamil break;
1420 1.25 kamil
1421 1.156 rillig case lsym_lbrace:
1422 1.157 rillig process_lbrace(&force_nl, &spaced_expr, hd, di_stack,
1423 1.146 rillig (int)array_length(di_stack), &decl_ind);
1424 1.25 kamil break;
1425 1.25 kamil
1426 1.156 rillig case lsym_rbrace:
1427 1.157 rillig process_rbrace(&spaced_expr, &decl_ind, di_stack);
1428 1.25 kamil break;
1429 1.25 kamil
1430 1.156 rillig case lsym_switch:
1431 1.157 rillig spaced_expr = true; /* the interesting stuff is done after the
1432 1.156 rillig * expressions are scanned */
1433 1.156 rillig hd = hd_switch; /* remember the type of header for later use
1434 1.164 rillig * by the parser */
1435 1.111 rillig goto copy_token;
1436 1.25 kamil
1437 1.156 rillig case lsym_for:
1438 1.157 rillig spaced_expr = true;
1439 1.156 rillig hd = hd_for;
1440 1.154 rillig goto copy_token;
1441 1.25 kamil
1442 1.156 rillig case lsym_if:
1443 1.157 rillig spaced_expr = true;
1444 1.156 rillig hd = hd_if;
1445 1.154 rillig goto copy_token;
1446 1.154 rillig
1447 1.156 rillig case lsym_while:
1448 1.157 rillig spaced_expr = true;
1449 1.156 rillig hd = hd_while;
1450 1.111 rillig goto copy_token;
1451 1.25 kamil
1452 1.156 rillig case lsym_do:
1453 1.153 rillig process_keyword_do(&force_nl, &last_else);
1454 1.153 rillig goto copy_token;
1455 1.153 rillig
1456 1.156 rillig case lsym_else:
1457 1.153 rillig process_keyword_else(&force_nl, &last_else);
1458 1.111 rillig goto copy_token;
1459 1.25 kamil
1460 1.156 rillig case lsym_typedef:
1461 1.156 rillig case lsym_storage_class:
1462 1.142 rillig blank_line_before = false;
1463 1.111 rillig goto copy_token;
1464 1.25 kamil
1465 1.156 rillig case lsym_tag:
1466 1.25 kamil if (ps.p_l_follow > 0)
1467 1.111 rillig goto copy_token;
1468 1.25 kamil /* FALLTHROUGH */
1469 1.156 rillig case lsym_type:
1470 1.164 rillig process_type(&decl_ind, &tabs_to_var);
1471 1.111 rillig goto copy_token;
1472 1.25 kamil
1473 1.156 rillig case lsym_funcname:
1474 1.164 rillig case lsym_ident:
1475 1.157 rillig process_ident(lsym, decl_ind, tabs_to_var, &spaced_expr,
1476 1.157 rillig &force_nl, hd);
1477 1.111 rillig copy_token:
1478 1.111 rillig copy_token();
1479 1.156 rillig if (lsym != lsym_funcname)
1480 1.25 kamil ps.want_blank = true;
1481 1.25 kamil break;
1482 1.25 kamil
1483 1.156 rillig case lsym_string_prefix:
1484 1.54 rillig process_string_prefix();
1485 1.25 kamil break;
1486 1.1 cgd
1487 1.156 rillig case lsym_period:
1488 1.54 rillig process_period();
1489 1.25 kamil break;
1490 1.25 kamil
1491 1.156 rillig case lsym_comma:
1492 1.105 rillig process_comma(decl_ind, tabs_to_var, &force_nl);
1493 1.25 kamil break;
1494 1.25 kamil
1495 1.164 rillig case lsym_preprocessing:
1496 1.54 rillig process_preprocessing();
1497 1.54 rillig break;
1498 1.119 rillig
1499 1.164 rillig case lsym_comment:
1500 1.56 rillig process_comment();
1501 1.25 kamil break;
1502 1.30 rillig
1503 1.30 rillig default:
1504 1.30 rillig break;
1505 1.64 rillig }
1506 1.25 kamil
1507 1.65 rillig *code.e = '\0';
1508 1.156 rillig if (lsym != lsym_comment && lsym != lsym_newline &&
1509 1.156 rillig lsym != lsym_preprocessing)
1510 1.156 rillig ps.last_token = lsym;
1511 1.53 rillig }
1512 1.53 rillig }
1513 1.53 rillig
1514 1.53 rillig int
1515 1.53 rillig main(int argc, char **argv)
1516 1.53 rillig {
1517 1.53 rillig main_init_globals();
1518 1.53 rillig main_parse_command_line(argc, argv);
1519 1.53 rillig #if HAVE_CAPSICUM
1520 1.53 rillig init_capsicum();
1521 1.53 rillig #endif
1522 1.53 rillig main_prepare_parsing();
1523 1.53 rillig main_loop();
1524 1.25 kamil }
1525 1.6 lukem
1526 1.48 rillig #ifdef debug
1527 1.48 rillig void
1528 1.48 rillig debug_printf(const char *fmt, ...)
1529 1.48 rillig {
1530 1.48 rillig FILE *f = output == stdout ? stderr : stdout;
1531 1.48 rillig va_list ap;
1532 1.48 rillig
1533 1.48 rillig va_start(ap, fmt);
1534 1.48 rillig vfprintf(f, fmt, ap);
1535 1.48 rillig va_end(ap);
1536 1.48 rillig }
1537 1.48 rillig
1538 1.48 rillig void
1539 1.48 rillig debug_println(const char *fmt, ...)
1540 1.48 rillig {
1541 1.48 rillig FILE *f = output == stdout ? stderr : stdout;
1542 1.48 rillig va_list ap;
1543 1.48 rillig
1544 1.48 rillig va_start(ap, fmt);
1545 1.48 rillig vfprintf(f, fmt, ap);
1546 1.48 rillig va_end(ap);
1547 1.48 rillig fprintf(f, "\n");
1548 1.48 rillig }
1549 1.48 rillig
1550 1.48 rillig void
1551 1.48 rillig debug_vis_range(const char *prefix, const char *s, const char *e,
1552 1.86 rillig const char *suffix)
1553 1.48 rillig {
1554 1.48 rillig debug_printf("%s", prefix);
1555 1.48 rillig for (const char *p = s; p < e; p++) {
1556 1.159 rillig if (*p == '\\' || *p == '"')
1557 1.159 rillig debug_printf("\\%c", *p);
1558 1.159 rillig else if (isprint((unsigned char)*p))
1559 1.48 rillig debug_printf("%c", *p);
1560 1.48 rillig else if (*p == '\n')
1561 1.48 rillig debug_printf("\\n");
1562 1.48 rillig else if (*p == '\t')
1563 1.48 rillig debug_printf("\\t");
1564 1.48 rillig else
1565 1.162 rillig debug_printf("\\x%02x", (unsigned char)*p);
1566 1.48 rillig }
1567 1.48 rillig debug_printf("%s", suffix);
1568 1.48 rillig }
1569 1.48 rillig #endif
1570 1.68 rillig
1571 1.68 rillig static void *
1572 1.68 rillig nonnull(void *p)
1573 1.68 rillig {
1574 1.68 rillig if (p == NULL)
1575 1.68 rillig err(EXIT_FAILURE, NULL);
1576 1.68 rillig return p;
1577 1.68 rillig }
1578 1.68 rillig
1579 1.68 rillig void *
1580 1.68 rillig xmalloc(size_t size)
1581 1.68 rillig {
1582 1.68 rillig return nonnull(malloc(size));
1583 1.68 rillig }
1584 1.68 rillig
1585 1.68 rillig void *
1586 1.68 rillig xrealloc(void *p, size_t new_size)
1587 1.68 rillig {
1588 1.68 rillig return nonnull(realloc(p, new_size));
1589 1.68 rillig }
1590 1.68 rillig
1591 1.68 rillig char *
1592 1.68 rillig xstrdup(const char *s)
1593 1.68 rillig {
1594 1.68 rillig return nonnull(strdup(s));
1595 1.68 rillig }
1596