usr.bin/indent/io.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-4-Clause
   3  *
   4  * Copyright (c) 1985 Sun Microsystems, Inc.
   5  * Copyright (c) 1980, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * @(#)io.c     8.1 (Berkeley) 6/6/93
  34  * $FreeBSD: head/usr.bin/indent/io.c 334927 2018-06-10 16:44:18Z pstef $
  35  */
  36
  37 #include <ctype.h>
  38 #include <err.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include "indent_globs.h"
  43 #include "indent.h"
  44
  45 /* Globals */
  46 int     found_err;
  47 int     n_real_blanklines;
  48 int     prefix_blankline_requested, postfix_blankline_requested;
  49 int     code_lines;
  50 int     had_eof;
  51 int     inhibit_formatting;
  52 int     suppress_blanklines;
  53
  54 int         comment_open;
  55 static int  paren_target;
  56 static int pad_output(int current, int target);
  57
  58 void
  59 dump_line(void)
  60 {                               /* dump_line is the routine that actually
  61                                  * effects the printing of the new source. It
  62                                  * prints the label section, followed by the
  63                                  * code section with the appropriate nesting
  64                                  * level, followed by any comments */
  65     int cur_col,
  66                 target_col = 1;
  67     static int  not_first_line;
  68
  69     if (ps.procname[0]) {
  70         ps.ind_level = 0;
  71         ps.procname[0] = 0;
  72     }
  73     if (s_code == e_code && s_lab == e_lab && s_com == e_com) {
  74         if (suppress_blanklines > 0)
  75             suppress_blanklines--;
  76         else {
  77             ps.bl_line = true;
  78             n_real_blanklines++;
  79         }
  80     }
  81     else if (!inhibit_formatting) {
  82         suppress_blanklines = 0;
  83         ps.bl_line = false;
  84         if (prefix_blankline_requested && not_first_line) {
  85             if (opt.swallow_optional_blanklines) {
  86                 if (n_real_blanklines == 1)
  87                     n_real_blanklines = 0;
  88             }
  89             else {
  90                 if (n_real_blanklines == 0)
  91                     n_real_blanklines = 1;
  92             }
  93         }
  94         while (--n_real_blanklines >= 0)
  95             putc('\n', output);
  96         n_real_blanklines = 0;
  97         if (ps.ind_level == 0)
  98             ps.ind_stmt = 0;    /* this is a class A kludge. dont do
  99                                  * additional statement indentation if we are
 100                                  * at bracket level 0 */
 101
 102         if (e_lab != s_lab || e_code != s_code)
 103             ++code_lines;       /* keep count of lines with code */
 104
 105
 106         if (e_lab != s_lab) {   /* print lab, if any */
 107             if (comment_open) {
 108                 comment_open = 0;
 109                 fprintf(output, ".*/\n");
 110             }
 111             while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
 112                 e_lab--;
 113             *e_lab = '\0';
 114             cur_col = pad_output(1, compute_label_target());
 115             if (s_lab[0] == '#' && (strncmp(s_lab, "#else", 5) == 0
 116                                     || strncmp(s_lab, "#endif", 6) == 0)) {
 117                 char *s = s_lab;
 118                 if (e_lab[-1] == '\n') e_lab--;
 119                 do putc(*s++, output);
 120                 while (s < e_lab && 'a' <= *s && *s<='z');
 121                 while ((*s == ' ' || *s == '\t') && s < e_lab)
 122                     s++;
 123                 if (s < e_lab)
 124                     fprintf(output, s[0]=='/' && s[1]=='*' ? "\t%.*s" : "\t/* %.*s */",
 125                             (int)(e_lab - s), s);
 126             }
 127             else fprintf(output, "%.*s", (int)(e_lab - s_lab), s_lab);
 128             cur_col = count_spaces(cur_col, s_lab);
 129         }
 130         else
 131             cur_col = 1;        /* there is no label section */
 132
 133         ps.pcase = false;
 134
 135         if (s_code != e_code) { /* print code section, if any */
 136             char *p;
 137
 138             if (comment_open) {
 139                 comment_open = 0;
 140                 fprintf(output, ".*/\n");
 141             }
 142             target_col = compute_code_target();
 143             {
 144                 int i;
 145
 146                 for (i = 0; i < ps.p_l_follow; i++)
 147                     if (ps.paren_indents[i] >= 0)
 148                         ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
 149             }
 150             cur_col = pad_output(cur_col, target_col);
 151             for (p = s_code; p < e_code; p++)
 152                 if (*p == (char) 0200)
 153                     fprintf(output, "%d", target_col * 7);
 154                 else
 155                     putc(*p, output);
 156             cur_col = count_spaces(cur_col, s_code);
 157         }
 158         if (s_com != e_com) {           /* print comment, if any */
 159             int target = ps.com_col;
 160             char *com_st = s_com;
 161
 162             target += ps.comment_delta;
 163             while (*com_st == '\t')     /* consider original indentation in
 164                                      * case this is a box comment */
 165                 com_st++, target += opt.tabsize;
 166             while (target <= 0)
 167                 if (*com_st == ' ')
 168                     target++, com_st++;
 169                 else if (*com_st == '\t') {
 170                     target = opt.tabsize * (1 + (target - 1) / opt.tabsize) + 1;
 171                     com_st++;
 172                 }
 173                 else
 174                     target = 1;
 175             if (cur_col > target) {     /* if comment can't fit on this line,
 176                                      * put it on next line */
 177                 putc('\n', output);
 178                 cur_col = 1;
 179                 ++ps.out_lines;
 180             }
 181             while (e_com > com_st && isspace((unsigned char)e_com[-1]))
 182                 e_com--;
 183             (void)pad_output(cur_col, target);
 184             fwrite(com_st, e_com - com_st, 1, output);
 185             ps.comment_delta = ps.n_comment_delta;
 186             ++ps.com_lines;     /* count lines with comments */
 187         }
 188         if (ps.use_ff)
 189             putc('\014', output);
 190         else
 191             putc('\n', output);
 192         ++ps.out_lines;
 193         if (ps.just_saw_decl == 1 && opt.blanklines_after_declarations) {
 194             prefix_blankline_requested = 1;
 195             ps.just_saw_decl = 0;
 196         }
 197         else
 198             prefix_blankline_requested = postfix_blankline_requested;
 199         postfix_blankline_requested = 0;
 200     }
 201     ps.decl_on_line = ps.in_decl;       /* if we are in the middle of a
 202                                          * declaration, remember that fact for
 203                                          * proper comment indentation */
 204     ps.ind_stmt = ps.in_stmt & ~ps.in_decl;     /* next line should be
 205                                                  * indented if we have not
 206                                                  * completed this stmt and if
 207                                                  * we are not in the middle of
 208                                                  * a declaration */
 209     ps.use_ff = false;
 210     ps.dumped_decl_indent = 0;
 211     *(e_lab = s_lab) = '\0';    /* reset buffers */
 212     *(e_code = s_code) = '\0';
 213     *(e_com = s_com = combuf + 1) = '\0';
 214     ps.ind_level = ps.i_l_follow;
 215     ps.paren_level = ps.p_l_follow;
 216     if (ps.paren_level > 0)
 217         paren_target = -ps.paren_indents[ps.paren_level - 1];
 218     not_first_line = 1;
 219 }
 220
 221 int
 222 compute_code_target(void)
 223 {
 224     int target_col = opt.ind_size * ps.ind_level + 1;
 225
 226     if (ps.paren_level)
 227         if (!opt.lineup_to_parens)
 228             target_col += opt.continuation_indent *
 229                 (2 * opt.continuation_indent == opt.ind_size ? 1 : ps.paren_level);
 230         else if (opt.lineup_to_parens_always)
 231             target_col = paren_target;
 232         else {
 233             int w;
 234             int t = paren_target;
 235
 236             if ((w = count_spaces(t, s_code) - opt.max_col) > 0
 237                     && count_spaces(target_col, s_code) <= opt.max_col) {
 238                 t -= w + 1;
 239                 if (t > target_col)
 240                     target_col = t;
 241             }
 242             else
 243                 target_col = t;
 244         }
 245     else if (ps.ind_stmt)
 246         target_col += opt.continuation_indent;
 247     return target_col;
 248 }
 249
 250 int
 251 compute_label_target(void)
 252 {
 253     return
 254         ps.pcase ? (int) (case_ind * opt.ind_size) + 1
 255         : *s_lab == '#' ? 1
 256         : opt.ind_size * (ps.ind_level - label_offset) + 1;
 257 }
 258
 259
 260 /*
 261  * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
 262  *
 263  * All rights reserved
 264  *
 265  *
 266  * NAME: fill_buffer
 267  *
 268  * FUNCTION: Reads one block of input into input_buffer
 269  *
 270  * HISTORY: initial coding      November 1976   D A Willcox of CAC 1/7/77 A
 271  * Willcox of CAC       Added check for switch back to partly full input
 272  * buffer from temporary buffer
 273  *
 274  */
 275 void
 276 fill_buffer(void)
 277 {                               /* this routine reads stuff from the input */
 278     char *p;
 279     int i;
 280     FILE *f = input;
 281
 282     if (bp_save != NULL) {      /* there is a partly filled input buffer left */
 283         buf_ptr = bp_save;      /* do not read anything, just switch buffers */
 284         buf_end = be_save;
 285         bp_save = be_save = NULL;
 286         if (buf_ptr < buf_end)
 287             return;             /* only return if there is really something in
 288                                  * this buffer */
 289     }
 290     for (p = in_buffer;;) {
 291         if (p >= in_buffer_limit) {
 292             int size = (in_buffer_limit - in_buffer) * 2 + 10;
 293             int offset = p - in_buffer;
 294             in_buffer = realloc(in_buffer, size);
 295             if (in_buffer == NULL)
 296                 errx(1, "input line too long");
 297             p = in_buffer + offset;
 298             in_buffer_limit = in_buffer + size - 2;
 299         }
 300         if ((i = getc(f)) == EOF) {
 301                 *p++ = ' ';
 302                 *p++ = '\n';
 303                 had_eof = true;
 304                 break;
 305         }
 306         if (i != '\0')
 307             *p++ = i;
 308         if (i == '\n')
 309                 break;
 310     }
 311     buf_ptr = in_buffer;
 312     buf_end = p;
 313     if (p - in_buffer > 2 && p[-2] == '/' && p[-3] == '*') {
 314         if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
 315             fill_buffer();      /* flush indent error message */
 316         else {
 317             int         com = 0;
 318
 319             p = in_buffer;
 320             while (*p == ' ' || *p == '\t')
 321                 p++;
 322             if (*p == '/' && p[1] == '*') {
 323                 p += 2;
 324                 while (*p == ' ' || *p == '\t')
 325                     p++;
 326                 if (p[0] == 'I' && p[1] == 'N' && p[2] == 'D' && p[3] == 'E'
 327                         && p[4] == 'N' && p[5] == 'T') {
 328                     p += 6;
 329                     while (*p == ' ' || *p == '\t')
 330                         p++;
 331                     if (*p == '*')
 332                         com = 1;
 333                     else if (*p == 'O') {
 334                         if (*++p == 'N')
 335                             p++, com = 1;
 336                         else if (*p == 'F' && *++p == 'F')
 337                             p++, com = 2;
 338                     }
 339                     while (*p == ' ' || *p == '\t')
 340                         p++;
 341                     if (p[0] == '*' && p[1] == '/' && p[2] == '\n' && com) {
 342                         if (s_com != e_com || s_lab != e_lab || s_code != e_code)
 343                             dump_line();
 344                         if (!(inhibit_formatting = com - 1)) {
 345                             n_real_blanklines = 0;
 346                             postfix_blankline_requested = 0;
 347                             prefix_blankline_requested = 0;
 348                             suppress_blanklines = 1;
 349                         }
 350                     }
 351                 }
 352             }
 353         }
 354     }
 355     if (inhibit_formatting) {
 356         p = in_buffer;
 357         do
 358             putc(*p, output);
 359         while (*p++ != '\n');
 360     }
 361 }
 362
 363 /*
 364  * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
 365  *
 366  * All rights reserved
 367  *
 368  *
 369  * NAME: pad_output
 370  *
 371  * FUNCTION: Writes tabs and spaces to move the current column up to the desired
 372  * position.
 373  *
 374  * ALGORITHM: Put tabs and/or blanks into pobuf, then write pobuf.
 375  *
 376  * PARAMETERS: current          integer         The current column target
 377  * nteger               The desired column
 378  *
 379  * RETURNS: Integer value of the new column.  (If current >= target, no action is
 380  * taken, and current is returned.
 381  *
 382  * GLOBALS: None
 383  *
 384  * CALLS: write (sys)
 385  *
 386  * CALLED BY: dump_line
 387  *
 388  * HISTORY: initial coding      November 1976   D A Willcox of CAC
 389  *
 390  */
 391 static int
 392 pad_output(int current, int target)
 393                                 /* writes tabs and blanks (if necessary) to
 394                                  * get the current output position up to the
 395                                  * target column */
 396     /* current: the current column value */
 397     /* target: position we want it at */
 398 {
 399     int curr;                   /* internal column pointer */
 400
 401     if (current >= target)
 402         return (current);       /* line is already long enough */
 403     curr = current;
 404     if (opt.use_tabs) {
 405         int tcur;
 406
 407         while ((tcur = opt.tabsize * (1 + (curr - 1) / opt.tabsize) + 1) <= target) {
 408             putc('\t', output);
 409             curr = tcur;
 410         }
 411     }
 412     while (curr++ < target)
 413         putc(' ', output);      /* pad with final blanks */
 414
 415     return (target);
 416 }
 417
 418 /*
 419  * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
 420  *
 421  * All rights reserved
 422  *
 423  *
 424  * NAME: count_spaces
 425  *
 426  * FUNCTION: Find out where printing of a given string will leave the current
 427  * character position on output.
 428  *
 429  * ALGORITHM: Run thru input string and add appropriate values to current
 430  * position.
 431  *
 432  * RETURNS: Integer value of position after printing "buffer" starting in column
 433  * "current".
 434  *
 435  * HISTORY: initial coding      November 1976   D A Willcox of CAC
 436  *
 437  */
 438 int
 439 count_spaces_until(int cur, char *buffer, char *end)
 440 /*
 441  * this routine figures out where the character position will be after
 442  * printing the text in buffer starting at column "current"
 443  */
 444 {
 445     char *buf;          /* used to look thru buffer */
 446
 447     for (buf = buffer; *buf != '\0' && buf != end; ++buf) {
 448         switch (*buf) {
 449
 450         case '\n':
 451         case 014:               /* form feed */
 452             cur = 1;
 453             break;
 454
 455         case '\t':
 456             cur = opt.tabsize * (1 + (cur - 1) / opt.tabsize) + 1;
 457             break;
 458
 459         case 010:               /* backspace */
 460             --cur;
 461             break;
 462
 463         default:
 464             ++cur;
 465             break;
 466         }                       /* end of switch */
 467     }                           /* end of for loop */
 468     return (cur);
 469 }
 470
 471 int
 472 count_spaces(int cur, char *buffer)
 473 {
 474     return (count_spaces_until(cur, buffer, NULL));
 475 }
 476
 477 void
 478 diag4(int level, const char *msg, int a, int b)
 479 {
 480     if (level)
 481         found_err = 1;
 482     if (output == stdout) {
 483         fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
 484         fprintf(stdout, msg, a, b);
 485         fprintf(stdout, " */\n");
 486     }
 487     else {
 488         fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
 489         fprintf(stderr, msg, a, b);
 490         fprintf(stderr, "\n");
 491     }
 492 }
 493
 494 void
 495 diag3(int level, const char *msg, int a)
 496 {
 497     if (level)
 498         found_err = 1;
 499     if (output == stdout) {
 500         fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
 501         fprintf(stdout, msg, a);
 502         fprintf(stdout, " */\n");
 503     }
 504     else {
 505         fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
 506         fprintf(stderr, msg, a);
 507         fprintf(stderr, "\n");
 508     }
 509 }
 510
 511 void
 512 diag2(int level, const char *msg)
 513 {
 514     if (level)
 515         found_err = 1;
 516     if (output == stdout) {
 517         fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
 518         fprintf(stdout, "%s", msg);
 519         fprintf(stdout, " */\n");
 520     }
 521     else {
 522         fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
 523         fprintf(stderr, "%s", msg);
 524         fprintf(stderr, "\n");
 525     }
 526 }