Home | History | Annotate | Line # | Download | only in indent
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