1 /* $NetBSD: pr_comment.c,v 1.128 2022/05/09 21:41:49 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 #if 0 41 static char sccsid[] = "@(#)pr_comment.c 8.1 (Berkeley) 6/6/93"; 42 #endif 43 44 #include <sys/cdefs.h> 45 #if defined(__NetBSD__) 46 __RCSID("$NetBSD: pr_comment.c,v 1.128 2022/05/09 21:41:49 rillig Exp $"); 47 #elif defined(__FreeBSD__) 48 __FBSDID("$FreeBSD: head/usr.bin/indent/pr_comment.c 334927 2018-06-10 16:44:18Z pstef $"); 49 #endif 50 51 #include <assert.h> 52 #include <stdio.h> 53 #include <string.h> 54 55 #include "indent.h" 56 57 static void 58 com_add_char(char ch) 59 { 60 if (1 >= com.l - com.e) 61 buf_expand(&com, 1); 62 *com.e++ = ch; 63 } 64 65 static void 66 com_add_delim(void) 67 { 68 if (!opt.star_comment_cont) 69 return; 70 const char *delim = " * "; 71 buf_add_range(&com, delim, delim + 3); 72 } 73 74 static void 75 com_terminate(void) 76 { 77 if (1 >= com.l - com.e) 78 buf_expand(&com, 1); 79 *com.e = '\0'; 80 } 81 82 static bool 83 fits_in_one_line(int com_ind, int max_line_length) 84 { 85 for (const char *p = inp_p(); *p != '\n'; p++) { 86 assert(*p != '\0'); 87 assert(inp_line_end() - p >= 2); 88 if (!(p[0] == '*' && p[1] == '/')) 89 continue; 90 91 int len = ind_add(com_ind + 3, inp_p(), p); 92 len += ch_isblank(p[-1]) ? 2 : 3; 93 return len <= max_line_length; 94 } 95 return false; 96 } 97 98 static void 99 analyze_comment(bool *p_may_wrap, bool *p_break_delim, 100 int *p_adj_max_line_length) 101 { 102 int adj_max_line_length; /* Adjusted max_line_length for comments that 103 * spill over the right margin */ 104 bool break_delim = opt.comment_delimiter_on_blankline; 105 int com_ind; 106 107 adj_max_line_length = opt.max_line_length; 108 bool may_wrap = true; 109 110 if (ps.curr_col_1 && !opt.format_col1_comments) { 111 may_wrap = false; 112 break_delim = false; 113 com_ind = 0; 114 115 } else { 116 if (inp_peek() == '-' || inp_peek() == '*' || 117 token.e[-1] == '/' || 118 (inp_peek() == '\n' && !opt.format_block_comments)) { 119 may_wrap = false; 120 break_delim = false; 121 } 122 123 /* 124 * XXX: This condition looks suspicious since it ignores the case 125 * where the end of the previous comment is still in 'com'. 126 * 127 * See test token_comment.c, keyword 'analyze_comment'. 128 */ 129 if (lab.s == lab.e && code.s == code.e) { 130 adj_max_line_length = opt.block_comment_max_line_length; 131 com_ind = (ps.ind_level - opt.unindent_displace) * opt.indent_size; 132 if (com_ind <= 0) 133 com_ind = opt.format_col1_comments ? 0 : 1; 134 135 } else { 136 break_delim = false; 137 138 int target_ind = code.s != code.e 139 ? ind_add(compute_code_indent(), code.s, code.e) 140 : ind_add(compute_label_indent(), lab.s, lab.e); 141 142 com_ind = ps.decl_on_line || ps.ind_level == 0 143 ? opt.decl_comment_column - 1 : opt.comment_column - 1; 144 if (com_ind <= target_ind) 145 com_ind = next_tab(target_ind); 146 if (com_ind + 25 > adj_max_line_length) 147 adj_max_line_length = com_ind + 25; 148 } 149 } 150 151 ps.com_ind = com_ind; 152 153 if (!may_wrap) { 154 /* 155 * Find out how much indentation there was originally, because that 156 * much will have to be ignored by output_complete_line. 157 */ 158 const char *start = inp_line_start(); 159 ps.n_comment_delta = -ind_add(0, start, inp_p() - 2); 160 } else { 161 ps.n_comment_delta = 0; 162 while (ch_isblank(inp_peek())) 163 inp_skip(); 164 } 165 166 ps.comment_delta = 0; 167 com_add_char('/'); 168 com_add_char(token.e[-1]); /* either '*' or '/' */ 169 170 /* TODO: Maybe preserve a single '\t' as well. */ 171 if (inp_peek() != ' ' && may_wrap) 172 com_add_char(' '); 173 174 if (break_delim && fits_in_one_line(com_ind, adj_max_line_length)) 175 break_delim = false; 176 177 if (break_delim) { 178 if (opt.blanklines_before_block_comments && 179 ps.prev_token != lsym_lbrace) 180 out.blank_line_before = true; 181 output_line(); 182 com_add_delim(); 183 } 184 185 *p_adj_max_line_length = adj_max_line_length; 186 *p_break_delim = break_delim; 187 *p_may_wrap = may_wrap; 188 } 189 190 /* 191 * Copy characters from 'inp' to 'com'. Try to keep comments from going over 192 * the maximum line length. To do that, remember where the last blank, tab, or 193 * newline was. When a line is filled, print up to the last blank and continue 194 * copying. 195 */ 196 static void 197 copy_comment_wrap(int adj_max_line_length, bool break_delim) 198 { 199 ssize_t last_blank = -1; /* index of the last blank in com.buf */ 200 201 for (;;) { 202 switch (inp_peek()) { 203 case '\f': 204 output_line_ff(); 205 last_blank = -1; 206 com_add_delim(); 207 inp_skip(); 208 while (ch_isblank(inp_peek())) 209 inp_skip(); 210 break; 211 212 case '\n': 213 if (had_eof) { 214 diag(1, "Unterminated comment"); 215 output_line(); 216 return; 217 } 218 219 last_blank = -1; 220 if (ps.next_col_1) { 221 if (com.s == com.e) 222 com_add_char(' '); /* force empty line of output */ 223 if (com.e - com.s > 3) { 224 output_line(); 225 com_add_delim(); 226 } 227 output_line(); 228 com_add_delim(); 229 230 } else { 231 ps.next_col_1 = true; 232 if (!(com.e > com.s && ch_isblank(com.e[-1]))) 233 com_add_char(' '); 234 last_blank = com.e - 1 - com.buf; 235 } 236 ++line_no; 237 238 bool skip_asterisk = true; 239 do { /* flush any blanks and/or tabs at start of 240 * next line */ 241 inp_skip(); 242 if (inp_peek() == '*' && skip_asterisk) { 243 skip_asterisk = false; 244 inp_skip(); 245 if (inp_peek() == '/') 246 goto end_of_comment; 247 } 248 } while (ch_isblank(inp_peek())); 249 250 break; /* end of case for newline */ 251 252 case '*': 253 inp_skip(); 254 if (inp_peek() == '/') { 255 end_of_comment: 256 inp_skip(); 257 258 if (break_delim) { 259 if (com.e - com.s > 3) 260 output_line(); 261 else 262 com.e = com.s; 263 com_add_char(' '); 264 } 265 266 if (!(com.e > com.s && ch_isblank(com.e[-1]))) 267 com_add_char(' '); 268 com_add_char('*'); 269 com_add_char('/'); 270 com_terminate(); 271 return; 272 273 } else /* handle isolated '*' */ 274 com_add_char('*'); 275 break; 276 277 default: /* we have a random char */ 278 ; 279 int now_len = ind_add(ps.com_ind, com.s, com.e); 280 for (;;) { 281 char ch = inp_next(); 282 if (ch_isblank(ch)) 283 last_blank = com.e - com.buf; 284 com_add_char(ch); 285 now_len++; 286 if (memchr("*\n\r\b\t", inp_peek(), 6) != NULL) 287 break; 288 if (now_len >= adj_max_line_length && last_blank != -1) 289 break; 290 } 291 292 ps.next_col_1 = false; 293 294 if (now_len <= adj_max_line_length) 295 break; 296 if (ch_isspace(com.e[-1])) 297 break; 298 299 if (last_blank == -1) { /* only a single word in this line */ 300 output_line(); 301 com_add_delim(); 302 break; 303 } 304 305 const char *last_word_s = com.buf + last_blank + 1; 306 size_t last_word_len = (size_t)(com.e - last_word_s); 307 com.e = com.buf + last_blank; 308 output_line(); 309 com_add_delim(); 310 311 memcpy(com.e, last_word_s, last_word_len); 312 com.e += last_word_len; 313 last_blank = -1; 314 } 315 } 316 } 317 318 static void 319 copy_comment_nowrap(void) 320 { 321 for (;;) { 322 if (inp_peek() == '\n') { 323 if (token.e[-1] == '/') { 324 com_terminate(); 325 return; 326 } 327 328 if (had_eof) { 329 diag(1, "Unterminated comment"); 330 output_line(); 331 return; 332 } 333 334 if (com.s == com.e) 335 com_add_char(' '); /* force output of an empty line */ 336 output_line(); 337 ++line_no; 338 inp_skip(); 339 continue; 340 } 341 342 com_add_char(inp_next()); 343 if (com.e[-2] == '*' && com.e[-1] == '/' && token.e[-1] == '*') { 344 com_terminate(); 345 return; 346 } 347 } 348 } 349 350 /* 351 * Scan, reformat and output a single comment, which is either a block comment 352 * starting with '/' '*' or an end-of-line comment starting with '//'. 353 */ 354 void 355 process_comment(void) 356 { 357 int adj_max_line_length; 358 bool may_wrap, break_delim; 359 360 ps.just_saw_decl = 0; 361 ps.stats.comments++; 362 363 int saved_just_saw_decl = ps.just_saw_decl; 364 analyze_comment(&may_wrap, &break_delim, &adj_max_line_length); 365 if (may_wrap) 366 copy_comment_wrap(adj_max_line_length, break_delim); 367 else 368 copy_comment_nowrap(); 369 ps.just_saw_decl = saved_just_saw_decl; 370 } 371