source: trunk/minix/commands/indent/io.c@ 11

/**
 * Copyright (c) 1985 Sun Microsystems, Inc.
 * Copyright (c) 1980 The Regents of the University of California.
 * Copyright (c) 1976 Board of Trustees of the University of Illinois.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley, the University of Illinois,
 * Urbana, and Sun Microsystems, Inc.  The name of either University
 * or Sun Microsystems may not be used to endorse or promote products
 * derived from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#define PUBLIC extern
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include "globs.h"
#include "proto.h"


int             comment_open;
static          paren_target;

void dump_line()
{                                       /* dump_line is the routine
                                           that actually effects the
                                           printing of the new source.
                                           It prints the label section,
                                           followed by the code section
                                           with the appropriate nesting
                                           level, followed by any
                                           comments */
   register int    cur_col, target_col;
   static          not_first_line;

   if (ps.procname[0])
   {
      if (troff)
      {
         if (comment_open)
         {
            comment_open = 0;
            fprintf(output, ".*/\n");
         }
         fprintf(output, ".Pr \"%s\"\n", ps.procname);
      }
      ps.ind_level = 0;
      ps.procname[0] = 0;
   }
   if (s_code == e_code && s_lab == e_lab && s_com == e_com)
   {
      if (suppress_blanklines > 0)
         suppress_blanklines--;
      else
      {
         ps.bl_line = true;
         n_real_blanklines++;
      }
   } else if (!inhibit_formatting)
   {
      suppress_blanklines = 0;
      ps.bl_line = false;
      if (prefix_blankline_requested && not_first_line)
         if (swallow_opt_bl)
         {
            if (n_real_blanklines == 1)
               n_real_blanklines = 0;
         } else
         {
            if (n_real_blanklines == 0)
               n_real_blanklines = 1;
         }
      while (--n_real_blanklines >= 0)
         putc('\n', output);
      n_real_blanklines = 0;
      if (ps.ind_level == 0)
         ps.ind_stmt = 0;               /* this is a class A kludge.
                                           dont do additional statement
                                           indentation if we are at
                                           bracket level 0 */

      if (e_lab != s_lab || e_code != s_code)
         ++code_lines;                  /* keep count of lines with
                                           code */


      if (e_lab != s_lab)
      {                                 /* print lab, if any */
         if (comment_open)
         {
            comment_open = 0;
            fprintf(output, ".*/\n");
         }
         while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
            e_lab--;
         cur_col = pad_output(1, label_target());
         fprintf(output, "%.*s", (int)(e_lab - s_lab), s_lab);
         cur_col = count_spaces(cur_col, s_lab);
      } else
         cur_col = 1;                   /* there is no label section */

      ps.pcase = false;

      if (s_code != e_code)
      {                                 /* print code section, if any */
         register char  *p;

         if (comment_open)
         {
            comment_open = 0;
            fprintf(output, ".*/\n");
         }
         target_col = code_target();
         {
            register        i;

            for (i = 0; i < ps.p_l_follow; i++)
               if (ps.paren_indents[i] >= 0)
                  ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
         }
         cur_col = pad_output(cur_col, target_col);
         for (p = s_code; p < e_code; p++)
            if (*p == (char) 0200)
               fprintf(output, "%d", target_col * 7);
            else
               putc(*p, output);
         cur_col = count_spaces(cur_col, s_code);
      }
      if (s_com != e_com)
         if (troff)
         {
            int             all_here = 0;
            register char  *p;

            if (e_com[-1] == '/' && e_com[-2] == '*')
               e_com -= 2, all_here++;
            while (e_com > s_com && e_com[-1] == ' ')
               e_com--;
            *e_com = 0;
            p = s_com;
            while (*p == ' ')
               p++;
            if (p[0] == '/' && p[1] == '*')
               p += 2, all_here++;
            else if (p[0] == '*')
               p += p[1] == '/' ? 2 : 1;
            while (*p == ' ')
               p++;
            if (*p == 0)
               goto inhibit_newline;
            if (comment_open < 2 && ps.box_com)
            {
               comment_open = 0;
               fprintf(output, ".*/\n");
            }
            if (comment_open == 0)
            {
               if ('a' <= *p && *p <= 'z')
                  *p = *p + 'A' - 'a';
               if (e_com - p < 50 && all_here == 2)
               {
                  register char  *follow = p;
                  fprintf(output, "\n.nr C! \\w\1");
                  while (follow < e_com)
                  {
                     switch (*follow)
                     {
                     case '\n':
                        putc(' ', output);
                     case 1:
                        break;
                     case '\\':
                        putc('\\', output);
                     default:
                        putc(*follow, output);
                     }
                     follow++;
                  }
                  putc(1, output);
               }
               fprintf(output, "\n./* %dp %d %dp\n",
                       ps.com_col * 7,
                    (s_code != e_code || s_lab != e_lab) - ps.box_com,
                       target_col * 7);
            }
            comment_open = 1 + ps.box_com;
            while (*p)
            {
               if (*p == BACKSLASH)
                  putc(BACKSLASH, output);
               putc(*p++, output);
            }
         } else
         {                              /* print comment, if any */
            register        target = ps.com_col;
            register char  *com_st = s_com;

            target += ps.comment_delta;
            while (*com_st == '\t')
               com_st++, target += 8;   /* ? */
            while (target <= 0)
               if (*com_st == ' ')
                  target++, com_st++;
               else if (*com_st == '\t')
                  target = ((target - 1) & ~7) + 9, com_st++;
               else
                  target = 1;
            if (cur_col > target)
            {                           /* if comment cant fit on this
                                           line, put it on next line */
               putc('\n', output);
               cur_col = 1;
               ++ps.out_lines;
            }
            while (e_com > com_st && isspace(e_com[-1]))
               e_com--;
            cur_col = pad_output(cur_col, target);
            if (!ps.box_com)
            {
               if (star_comment_cont && (com_st[1] != '*' || e_com <= com_st + 1))
                  if (com_st[1] == ' ' && com_st[0] == ' ' && e_com > com_st + 1)
                     com_st[1] = '*';
                  else
                     fwrite(" * ", com_st[0] == '\t' ? 2 : com_st[0] == '*' ? 1 : 3, 1, output);
            }
            fwrite(com_st, (int)(e_com - com_st), 1, output);
            ps.comment_delta = ps.n_comment_delta;
            cur_col = count_spaces(cur_col, com_st);
            ++ps.com_lines;             /* count lines with comments */
         }
      if (ps.use_ff)
         putc('\014', output);
      else
         putc('\n', output);
inhibit_newline:
      ++ps.out_lines;
      if (ps.just_saw_decl == 1 && bl_aft_decl)
      {
         prefix_blankline_requested = 1;
         ps.just_saw_decl = 0;
      } else
         prefix_blankline_requested = postfix_blankline_requested;
      postfix_blankline_requested = 0;
   }
   ps.decl_on_line = ps.in_decl;        /* if we are in the middle of a
                                           declaration, remember that
                                           fact for proper comment
                                           indentation */
   ps.ind_stmt = ps.in_stmt & ~ps.in_decl;      /* next line should be
                                                   indented if we have
                                                   not completed this
                                                   stmt and if we are
                                                   not in the middle of
                                                   a declaration */
   ps.use_ff = false;
   ps.dumped_decl_indent = 0;
   *(e_lab = s_lab) = '\0';             /* reset buffers */
   *(e_code = s_code) = '\0';
   *(e_com = s_com) = '\0';
   ps.ind_level = ps.i_l_follow;
   ps.paren_level = ps.p_l_follow;
   paren_target = -ps.paren_indents[ps.paren_level - 1];
   not_first_line = 1;
   return;
}

int code_target()
{
   register        target_col = ps.ind_size * ps.ind_level + 1;

   if (ps.paren_level)
      if (!lineup_to_parens)
         target_col += continuation_indent * ps.paren_level;
      else
      {
         register        w;
         register        t = paren_target;

         if ((w = count_spaces(t, s_code) - max_col) > 0
             && count_spaces(target_col, s_code) <= max_col)
         {
            t -= w + 1;
            if (t > target_col)
               target_col = t;
         } else
            target_col = t;
      }
   else if (ps.ind_stmt)
      target_col += continuation_indent;
   return target_col;
}

int label_target()
{
   return
      ps.pcase ? (int) (case_ind * ps.ind_size) + 1
      : *s_lab == '#' ? 1
      : ps.ind_size * (ps.ind_level - label_offset) + 1;
}


/*
 * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
 *
 * All rights reserved
 *
 *
 * NAME: fill_buffer
 *
 * FUNCTION: Reads one block of input into input_buffer
 *
 * HISTORY: initial coding      November 1976   D A Willcox of CAC 1/7/77 A
 * Willcox of CAC       Added check for switch back to partly full input
 * buffer from temporary buffer
 *
 */

void
fill_buffer()
{                                       /* this routine reads stuff
                                           from the input */
   register char  *p;
   register int    i;
   register FILE  *f = input;

   if (bp_save != 0)
   {                                    /* there is a partly filled
                                           input buffer left */
      buf_ptr = bp_save;                /* dont read anything, just
                                           switch buffers */
      buf_end = be_save;
      bp_save = be_save = 0;
      if (buf_ptr < buf_end)
         return;                        /* only return if there is
                                           really something in this
                                           buffer */
   }
   for (p = buf_ptr = in_buffer;;)
   {
      if ((i = getc(f)) == EOF)
      {
         *p++ = ' ';
         *p++ = '\n';
         had_eof = true;
         break;
      }
      *p++ = (char)i;
      if (i == '\n')
         break;
   }
   buf_end = p;
   if (p[-2] == '/' && p[-3] == '*')
   {
      if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
         fill_buffer();                 /* flush indent error message */
      else
      {
         int             com = 0;

         p = in_buffer;
         while (*p == ' ' || *p == '\t')
            p++;
         if (*p == '/' && p[1] == '*')
         {
            p += 2;
            while (*p == ' ' || *p == '\t')
               p++;
            if (p[0] == 'I' && p[1] == 'N' && p[2] == 'D' && p[3] == 'E'
                && p[4] == 'N' && p[5] == 'T')
            {
               p += 6;
               while (*p == ' ' || *p == '\t')
                  p++;
               if (*p == '*')
                  com = 1;
               else if (*p == 'O')
                  if (*++p == 'N')
                     p++, com = 1;
                  else if (*p == 'F' && *++p == 'F')
                     p++, com = 2;
               while (*p == ' ' || *p == '\t')
                  p++;
               if (p[0] == '*' && p[1] == '/' && p[2] == '\n' && com)
               {
                  if (s_com != e_com || s_lab != e_lab || s_code != e_code)
                     dump_line();
                  if (!(inhibit_formatting = com - 1))
                  {
                     n_real_blanklines = 0;
                     postfix_blankline_requested = 0;
                     prefix_blankline_requested = 0;
                     suppress_blanklines = 1;
                  }
               }
            }
         }
      }
   }
   if (inhibit_formatting)
   {
      p = in_buffer;
      do
         putc(*p, output);
      while (*p++ != '\n');
   }
   return;
}

/*
 * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
 *
 * All rights reserved
 *
 *
 * NAME: pad_output
 *
 * FUNCTION: Writes tabs and spaces to move the current column up to the desired
 * position.
 *
 * ALGORITHM: Put tabs and/or blanks into pobuf, then write pobuf.
 *
 * PARAMETERS: current          integer         The current column target
 * nteger               The desired column
 *
 * RETURNS: Integer value of the new column.  (If current >= target, no action
 * is taken, and current is returned.
 *
 * GLOBALS: None
 *
 * CALLS: write (sys)
 *
 * CALLED BY: dump_line
 *
 * HISTORY: initial coding      November 1976   D A Willcox of CAC
 *
 */

int pad_output(current, target)         /* writes tabs and blanks (if
                                           necessary) to get the
                                           current output position up
                                           to the target column */
   int             current;             /* the current column value */
   int             target;              /* position we want it at */
{
   register int    curr;                /* internal column pointer */
   register int    tcur;

   if (troff)
      fprintf(output, "\\h'|%dp'", (target - 1) * 7);
   else
   {
      if (current >= target)
         return (current);              /* line is already long enough */
      curr = current;
      while ((tcur = ((curr - 1) & tabmask) + tabsize + 1) <= target)
      {
         putc('\t', output);
         curr = tcur;
      }
      while (curr++ < target)
         putc(' ', output);             /* pad with final blanks */
   }
   return (target);
}

/*
 * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
 *
 * All rights reserved
 *
 *
 * NAME: count_spaces
 *
 * FUNCTION: Find out where printing of a given string will leave the current
 * character position on output.
 *
 * ALGORITHM: Run thru input string and add appropriate values to current
 * position.
 *
 * RETURNS: Integer value of position after printing "buffer" starting in column
 * "current".
 *
 * HISTORY: initial coding      November 1976   D A Willcox of CAC
 *
 */

int
count_spaces(current, buffer)
/*
 * this routine figures out where the character position will be after
 * printing the text in buffer starting at column "current"
 */
   int             current;
   char           *buffer;
{
   register char  *buf;                 /* used to look thru buffer */
   register int    cur;                 /* current character counter */

   cur = current;

   for (buf = buffer; *buf != '\0'; ++buf)
   {
      switch (*buf)
      {

      case '\n':
      case 014:                 /* form feed */
         cur = 1;
         break;

      case '\t':
         cur = ((cur - 1) & tabmask) + tabsize + 1;
         break;

      case '':                         /* this is a backspace */
         --cur;
         break;

      default:
         ++cur;
         break;
      }                                 /* end of switch */
   }                                    /* end of for loop */
   return (cur);
}

int             found_err;
void diag(level, msg, a, b)
int level;
char *msg;
int a, b;
{
   if (level)
      found_err = 1;
   if (output == stdout)
   {
      fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
      fprintf(stdout, msg, a, b);
      fprintf(stdout, " */\n");
   } else
   {
      fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
      fprintf(stderr, msg, a, b);
      fprintf(stderr, "\n");
   }
}

void writefdef(f, nm)
   register struct fstate *f;
   int nm;
{
   fprintf(output, ".ds f%c %s\n.nr s%c %d\n",
           nm, f->font, nm, f->size);
}

char           *
chfont(of, nf, s)
   register struct fstate *of, *nf;
   char           *s;
{
   if (of->font[0] != nf->font[0]
       || of->font[1] != nf->font[1])
   {
      *s++ = '\\';
      *s++ = 'f';
      if (nf->font[1])
      {
         *s++ = '(';
         *s++ = nf->font[0];
         *s++ = nf->font[1];
      } else
         *s++ = nf->font[0];
   }
   if (nf->size != of->size)
   {
      *s++ = '\\';
      *s++ = 's';
      if (nf->size < of->size)
      {
         *s++ = '-';
         *s++ = (char)'0' + of->size - nf->size;
      } else
      {
         *s++ = '+';
         *s++ = (char)'0' + nf->size - of->size;
      }
   }
   return s;
}


void parsefont(f, s0)
   register struct fstate *f;
   char           *s0;
{
   register char  *s = s0;
   int             sizedelta = 0;
   memset(f, '\0', sizeof *f);
   while (*s)
   {
      if (isdigit(*s))
         f->size = f->size * 10 + *s - '0';
      else if (isupper(*s))
         if (f->font[0])
            f->font[1] = *s;
         else
            f->font[0] = *s;
      else if (*s == 'c')
         f->allcaps = 1;
      else if (*s == '+')
         sizedelta++;
      else if (*s == '-')
         sizedelta--;
      else
      {
         fprintf(stderr, "indent: bad font specification: %s\n", s0);
         exit(1);
      }
      s++;
   }
   if (f->font[0] == 0)
      f->font[0] = 'R';
   if (bodyf.size == 0)
      bodyf.size = 11;
   if (f->size == 0)
      f->size = bodyf.size + sizedelta;
   else if (sizedelta > 0)
      f->size += bodyf.size;
   else
      f->size = bodyf.size - f->size;
}