1 /* $NetBSD: io.c,v 1.237 2025/01/04 10:28:08 rillig Exp $ */ 2 3 /*- 4 * SPDX-License-Identifier: BSD-4-Clause 5 * 6 * Copyright (c) 1985 Sun Microsystems, Inc. 7 * Copyright (c) 1980, 1993 8 * The Regents of the University of California. All rights reserved. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the University of 22 * California, Berkeley and its contributors. 23 * 4. Neither the name of the University nor the names of its contributors 24 * may be used to endorse or promote products derived from this software 25 * without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 37 * SUCH DAMAGE. 38 */ 39 40 #include <sys/cdefs.h> 41 __RCSID("$NetBSD: io.c,v 1.237 2025/01/04 10:28:08 rillig Exp $"); 42 43 #include <err.h> 44 #include <stdio.h> 45 46 #include "indent.h" 47 48 struct input_state in = { 49 .token_end_line = 1, 50 }; 51 52 struct output_state out; 53 enum indent_enabled indent_enabled; 54 static int out_ind; /* width of the line that is being written */ 55 static unsigned newlines = 2; /* the total of written and buffered newlines; 56 * 0 in the middle of a line, 1 after a single 57 * finished line, anything > 1 are trailing 58 * blank lines */ 59 static unsigned buffered_newlines; /* not yet written */ 60 static int paren_indent; /* total indentation when parenthesized */ 61 62 63 static void 64 inp_read_next_line(void) 65 { 66 buf_clear(&in.line); 67 68 for (;;) { 69 int ch = getc(in.f); 70 if (ch == EOF) { 71 if (indent_enabled == indent_on) { 72 buf_add_char(&in.line, ' '); 73 buf_add_char(&in.line, '\n'); 74 } 75 had_eof = true; 76 break; 77 } 78 79 if (ch != '\0') 80 buf_add_char(&in.line, (char)ch); 81 if (ch == '\n') 82 break; 83 } 84 buf_terminate(&in.line); 85 in.p = in.line.s; 86 } 87 88 void 89 inp_read_line(void) 90 { 91 if (indent_enabled == indent_on) 92 buf_clear(&out.indent_off_text); 93 buf_add_chars(&out.indent_off_text, in.line.s, in.line.len); 94 inp_read_next_line(); 95 } 96 97 void 98 inp_skip(void) 99 { 100 in.p++; 101 if ((size_t)(in.p - in.line.s) >= in.line.len) 102 inp_read_line(); 103 } 104 105 char 106 inp_next(void) 107 { 108 char ch = in.p[0]; 109 inp_skip(); 110 return ch; 111 } 112 113 114 static void 115 add_buffered_newline(void) 116 { 117 buffered_newlines++; 118 newlines++; 119 out_ind = 0; 120 } 121 122 static void 123 write_buffered_newlines(void) 124 { 125 for (; buffered_newlines > 0; buffered_newlines--) { 126 if (fputc('\n', output) == EOF) 127 err(1, "cannot write output"); 128 debug_println("write_newline"); 129 } 130 } 131 132 static void 133 write_range(const char *s, size_t len) 134 { 135 write_buffered_newlines(); 136 if (fwrite(s, 1, len, output) != len) 137 err(1, "cannot write output"); 138 debug_printf("write_range "); 139 debug_vis_range(s, len); 140 debug_println(""); 141 for (size_t i = 0; i < len; i++) 142 newlines = s[i] == '\n' ? newlines + 1 : 0; 143 out_ind = ind_add(out_ind, s, len); 144 } 145 146 static void 147 write_indent(int new_ind) 148 { 149 write_buffered_newlines(); 150 151 int ind = out_ind; 152 153 if (opt.use_tabs) { 154 int n = new_ind / opt.tabsize - ind / opt.tabsize; 155 if (n > 0) { 156 ind = ind - ind % opt.tabsize + n * opt.tabsize; 157 while (n-- > 0) 158 if (fputc('\t', output) == EOF) 159 err(1, "cannot write output"); 160 newlines = 0; 161 } 162 } 163 164 for (; ind < new_ind; ind++) { 165 if (fputc(' ', output) == EOF) 166 err(1, "cannot write output"); 167 newlines = 0; 168 } 169 170 debug_println("write_indent %d", ind); 171 out_ind = ind; 172 } 173 174 static bool 175 want_blank_line(void) 176 { 177 debug_println("%s: %s -> %s", __func__, 178 line_kind_name[out.prev_line_kind], line_kind_name[out.line_kind]); 179 debug_blank_line(); 180 181 if (((ps.blank_line_after_decl && ps.declaration == decl_no) 182 || ps.badp == badp_yes) 183 && (lab.len > 0 || code.len > 0)) { 184 ps.blank_line_after_decl = false; 185 ps.badp = badp_none; 186 return true; 187 } 188 189 if (opt.blank_line_around_conditional_compilation) { 190 if (out.prev_line_kind != lk_pre_if 191 && out.line_kind == lk_pre_if) 192 return true; 193 if (out.prev_line_kind == lk_pre_endif 194 && out.line_kind != lk_pre_endif) 195 return true; 196 } 197 if (opt.blank_line_after_proc && out.prev_line_kind == lk_func_end 198 && out.line_kind != lk_pre_endif && out.line_kind != lk_pre_other) 199 return true; 200 if (opt.blank_line_before_block_comment 201 && out.line_kind == lk_block_comment) 202 return true; 203 return false; 204 } 205 206 static bool 207 is_blank_line_optional(void) 208 { 209 if (out.prev_line_kind == lk_stmt_head) 210 return newlines >= 1; 211 if (ps.psyms.len >= 3) 212 return newlines >= 2; 213 return newlines >= 3; 214 } 215 216 static int 217 compute_case_label_indent(void) 218 { 219 size_t i = ps.psyms.len - 1; 220 while (i > 0 && ps.psyms.sym[i] != psym_switch_expr) 221 i--; 222 float case_ind = (float)ps.psyms.ind_level[i] + opt.case_indent; 223 // TODO: case_ind may become negative here. 224 return (int)(case_ind * (float)opt.indent_size); 225 } 226 227 int 228 compute_label_indent(void) 229 { 230 if (out.line_kind == lk_case_or_default) 231 return compute_case_label_indent(); 232 if (lab.s[0] == '#') 233 return 0; 234 // TODO: the indentation may become negative here. 235 return opt.indent_size * (ps.ind_level - 2); 236 } 237 238 static void 239 output_line_label(void) 240 { 241 write_indent(compute_label_indent()); 242 write_range(lab.s, lab.len); 243 } 244 245 static int 246 compute_lined_up_code_indent(int base_ind) 247 { 248 int ind = paren_indent; 249 int overflow = ind_add(ind, code.s, code.len) - opt.max_line_length; 250 if (overflow >= 0 251 && ind_add(base_ind, code.s, code.len) < opt.max_line_length) { 252 ind -= 2 + overflow; 253 if (ind < base_ind) 254 ind = base_ind; 255 } 256 257 if (ps.extra_expr_indent != eei_no 258 && ind == base_ind + opt.indent_size) 259 ind += opt.continuation_indent; 260 return ind; 261 } 262 263 int 264 compute_code_indent(void) 265 { 266 int base_ind = ps.ind_level * opt.indent_size; 267 268 if (ps.ind_paren_level == 0) { 269 if (ps.line_is_stmt_cont) 270 return base_ind + opt.continuation_indent; 271 return base_ind; 272 } 273 274 if (opt.lineup_to_parens) { 275 if (opt.lineup_to_parens_always) 276 return paren_indent; 277 return compute_lined_up_code_indent(base_ind); 278 } 279 280 int rel_ind = opt.continuation_indent * ps.ind_paren_level; 281 if (ps.extra_expr_indent != eei_no && rel_ind == opt.indent_size) 282 rel_ind += opt.continuation_indent; 283 return base_ind + rel_ind; 284 } 285 286 static void 287 output_line_code(void) 288 { 289 int target_ind = compute_code_indent(); 290 for (size_t i = 0; i < ps.paren.len; i++) { 291 int paren_ind = ps.paren.item[i].indent; 292 if (paren_ind >= 0) { 293 ps.paren.item[i].indent = 294 -1 - (paren_ind + target_ind); 295 debug_println( 296 "setting paren_indents[%zu] from %d to %d " 297 "for column %d", 298 i, paren_ind, 299 ps.paren.item[i].indent, target_ind + 1); 300 } 301 } 302 303 if (lab.len > 0 && target_ind <= out_ind) 304 write_range(" ", 1); 305 write_indent(target_ind); 306 write_range(code.s, code.len); 307 } 308 309 static void 310 output_comment(void) 311 { 312 int target_ind = ps.comment_ind; 313 const char *p; 314 315 if (ps.comment_cont) 316 target_ind += ps.comment_shift; 317 ps.comment_cont = true; 318 319 /* consider the original indentation in case this is a box comment */ 320 for (p = com.s; *p == '\t'; p++) 321 target_ind += opt.tabsize; 322 323 for (; target_ind < 0; p++) { 324 if (*p == ' ') 325 target_ind++; 326 else if (*p == '\t') 327 target_ind = next_tab(target_ind); 328 else { 329 target_ind = 0; 330 break; 331 } 332 } 333 334 if (out_ind > target_ind) 335 add_buffered_newline(); 336 337 while (com.s + com.len > p && ch_isspace(com.s[com.len - 1])) 338 com.len--; 339 buf_terminate(&com); 340 341 write_indent(target_ind); 342 write_range(p, com.len - (size_t)(p - com.s)); 343 } 344 345 /* 346 * Write a line of formatted source to the output file. The line consists of 347 * the label, the code and the comment. 348 */ 349 static void 350 output_indented_line(void) 351 { 352 if (lab.len == 0 && code.len == 0 && com.len == 0) 353 out.line_kind = lk_blank; 354 355 if (want_blank_line() && newlines < 2 && out.line_kind != lk_blank) 356 add_buffered_newline(); 357 358 /* This kludge aligns function definitions correctly. */ 359 if (ps.ind_level == 0) 360 ps.line_is_stmt_cont = false; 361 362 if (opt.blank_line_after_decl && ps.declaration == decl_end 363 && ps.psyms.len > 2) { 364 ps.declaration = decl_no; 365 ps.blank_line_after_decl = true; 366 } 367 368 if (opt.swallow_optional_blank_lines 369 && out.line_kind == lk_blank 370 && is_blank_line_optional()) 371 return; 372 373 if (lab.len > 0) 374 output_line_label(); 375 if (code.len > 0) 376 output_line_code(); 377 if (com.len > 0) 378 output_comment(); 379 add_buffered_newline(); 380 if (out.line_kind != lk_blank) 381 write_buffered_newlines(); 382 383 out.prev_line_kind = out.line_kind; 384 } 385 386 static bool 387 is_stmt_cont(void) 388 { 389 if (ps.psyms.len >= 2 390 && ps.psyms.sym[ps.psyms.len - 2] == psym_lbrace_enum 391 && ps.prev_lsym == lsym_comma 392 && ps.paren.len == 0) 393 return false; 394 return ps.in_stmt_or_decl 395 && (!ps.in_decl || ps.in_init) 396 && ps.init_level == 0; 397 } 398 399 static void 400 prepare_next_line(void) 401 { 402 ps.line_has_decl = ps.in_decl; 403 ps.line_has_func_def = false; 404 ps.line_is_stmt_cont = is_stmt_cont(); 405 ps.decl_indent_done = false; 406 if (ps.extra_expr_indent == eei_last) 407 ps.extra_expr_indent = eei_no; 408 if (!(ps.psyms.sym[ps.psyms.len - 1] == psym_if_expr_stmt_else 409 && ps.paren.len > 0)) 410 ps.ind_level = ps.ind_level_follow; 411 ps.ind_paren_level = (int)ps.paren.len; 412 ps.want_blank = false; 413 if ((ps.badp == badp_seen_lbrace || ps.badp == badp_seen_decl) 414 && !ps.in_decl) 415 ps.badp = badp_yes; 416 417 if (ps.paren.len > 0) { 418 /* TODO: explain what negative indentation means */ 419 paren_indent = -1 - ps.paren.item[ps.paren.len - 1].indent; 420 debug_println("paren_indent is now %d", paren_indent); 421 } 422 423 out.line_kind = lk_other; 424 } 425 426 void 427 output_line(void) 428 { 429 debug_blank_line(); 430 debug_buffers(__func__); 431 432 if (indent_enabled == indent_on) 433 output_indented_line(); 434 else if (indent_enabled == indent_last_off_line) { 435 indent_enabled = indent_on; 436 write_range(out.indent_off_text.s, out.indent_off_text.len); 437 buf_clear(&out.indent_off_text); 438 } 439 440 buf_clear(&lab); 441 buf_clear(&code); 442 buf_clear(&com); 443 444 prepare_next_line(); 445 } 446 447 void 448 finish_output(void) 449 { 450 output_line(); 451 if (indent_enabled != indent_on) { 452 indent_enabled = indent_last_off_line; 453 output_line(); 454 } 455 if (fflush(output) != 0) 456 err(1, "output file"); 457 } 458
Indexes created Sun Sep 21 14:09:52 GMT 2025