Logo Search packages:      
Sourcecode: uncrustify version File versions

output.cpp

/**
 * @file output.cpp
 * Does all the output & comment formatting.
 *
 * @author  Ben Gardner
 * @license GPL v2+
 *
 * $Id: output.cpp 678 2007-02-24 18:36:03Z bengardner $
 */

#include "uncrustify_types.h"
#include "prototypes.h"
#include "chunk_list.h"
#include <cstring>
#include <cstdlib>



void add_char(char ch)
{
   /* convert a newline into the LF/CRLF/CR sequence */
   if (ch == '\n')
   {
      fputs(cpd.newline, cpd.fout);
      cpd.column      = 1;
      cpd.did_newline = 1;
   }
   else
   {
      fputc(ch, cpd.fout);
      if (ch == '\t')
      {
         cpd.column = next_tab_column(cpd.column);
      }
      else
      {
         cpd.column++;
      }
   }
}

void add_text(const char *text)
{
   char ch;

   while ((ch = *text) != 0)
   {
      text++;
      add_char(ch);
   }
}

void add_text_len(const char *text, int len)
{
   while (len-- > 0)
   {
      add_char(*text);
      text++;
   }
}


/**
 * Advance to a specific column
 * cpd.column is the current column
 *
 * @param column  The column to advance to
 */
00069 void output_to_column(int column, bool allow_tabs)
{
   int nc;

   cpd.did_newline = 0;
   if (allow_tabs)
   {
      /* tab out as far as possible and then use spaces */
      while ((nc = next_tab_column(cpd.column)) <= column)
      {
         add_text("\t");
      }
   }
   /* space out the final bit */
   while (cpd.column < column)
   {
      add_text(" ");
   }
}

void output_indent(int column, int brace_col)
{
   if ((cpd.column == 1) && (cpd.settings[UO_indent_with_tabs].n != 0))
   {
      if (cpd.settings[UO_indent_with_tabs].n == 2)
      {
         brace_col = column;
      }

      /* tab out as far as possible and then use spaces */
      int nc;
      while ((nc = next_tab_column(cpd.column)) <= brace_col)
      {
         add_text("\t");
      }
   }

   /* space out the rest */
   while (cpd.column < column)
   {
      add_text(" ");
   }
}



void output_parsed(FILE *pfile)
{
   chunk_t *pc;
   int     cnt;

   output_options(pfile);
   output_defines(pfile);
   output_types(pfile);

   fprintf(pfile, "-=====-\n");
   fprintf(pfile, "Line      Tag          Parent     Columns  Br/Lvl/pp Flg Nl  Text");
   for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc))
   {
      fprintf(pfile, "\n%3d> %13.13s[%13.13s][%2d/%2d/%2d][%d/%d/%d][%6x][%d-%d]",
              pc->orig_line, get_token_name(pc->type),
              get_token_name(pc->parent_type),
              pc->column, pc->orig_col, pc->orig_col_end,
              pc->brace_level, pc->level, pc->pp_level,
              pc->flags, pc->nl_count, pc->after_tab);

      if ((pc->type != CT_NEWLINE) && (pc->len != 0))
      {
         for (cnt = 0; cnt < pc->column; cnt++)
         {
            fprintf(pfile, " ");
         }
         fprintf(pfile, "%.*s", pc->len, pc->str);
      }
   }
   fprintf(pfile, "\n-=====-\n");
   fflush(pfile);
}

void output_options(FILE *pfile)
{
   int idx;
   const option_map_value *ptr;

   fprintf(pfile, "-== Options ==-\n");
   for (idx = 0; idx < UO_option_count; idx++)
   {
      ptr = get_option_name(idx);
      if (ptr != NULL)
      {
         if (ptr->type == AT_BOOL)
         {
            fprintf(pfile, "%3d) %32s = %s\n",
                    ptr->id, ptr->name,
                    cpd.settings[ptr->id].b ? "True" : "False");
         }
         else if (ptr->type == AT_IARF)
         {
            fprintf(pfile, "%3d) %32s = %s\n",
                    ptr->id, ptr->name,
                    (cpd.settings[ptr->id].a == AV_ADD) ? "Add" :
                    (cpd.settings[ptr->id].a == AV_REMOVE) ? "Remove" :
                    (cpd.settings[ptr->id].a == AV_FORCE) ? "Force" : "Ignore");
         }
         else if (ptr->type == AT_LINE)
         {
            fprintf(pfile, "%3d) %32s = %s\n",
                    ptr->id, ptr->name,
                    (cpd.settings[ptr->id].le == LE_AUTO) ? "Auto" :
                    (cpd.settings[ptr->id].le == LE_LF) ? "LF" :
                    (cpd.settings[ptr->id].le == LE_CRLF) ? "CRLF" :
                    (cpd.settings[ptr->id].le == LE_CR) ? "CR" : "???");
         }
         else  /* AT_NUM */
         {
            fprintf(pfile, "%3d) %32s = %d\n",
                    ptr->id, ptr->name, cpd.settings[ptr->id].n);
         }
      }
   }
}

/**
 * This renders the chunk list to a file.
 */
00194 void output_text(FILE *pfile)
{
   chunk_t *pc;
   chunk_t *prev;
   int     cnt;
   int     lvlcol;
   bool    allow_tabs;

   cpd.fout = pfile;

   cpd.column = 1;
   for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc))
   {
      if (pc->type == CT_NEWLINE)
      {
         for (cnt = 0; cnt < pc->nl_count; cnt++)
         {
            add_char('\n');
         }
         cpd.did_newline = 1;
         cpd.column      = 1;
         LOG_FMT(LOUTIND, " xx\n");
      }
      else if (pc->type == CT_COMMENT_MULTI)
      {
         output_comment_multi(pc);
      }
      else if (pc->type == CT_COMMENT_CPP)
      {
         pc = output_comment_cpp(pc);
      }
      else if (pc->len == 0)
      {
         /* don't do anything for non-visible stuff */
         LOG_FMT(LOUTIND, " <%d> -", pc->column);
      }
      else
      {
         /* indent to the 'level' first */
         if (cpd.did_newline)
         {
            if (cpd.settings[UO_indent_with_tabs].n == 1)
            {
               /* FIXME: it would be better to properly set column_indent in
                * indent_text(), but this hack for '}' and ':' seems to work. */
               if ((pc->type == CT_BRACE_CLOSE) ||
                   chunk_is_str(pc, ":", 1))
               {
                  lvlcol = pc->column;
               }
               else
               {
                  lvlcol = pc->column_indent;
                  if (lvlcol > pc->column)
                  {
                     lvlcol = pc->column;
                  }
               }

               if (lvlcol > 1)
               {
                  output_to_column(lvlcol, true);
               }
            }
            allow_tabs = (cpd.settings[UO_indent_with_tabs].n == 2) ||
                         (chunk_is_comment(pc) &&
                          (cpd.settings[UO_indent_with_tabs].n != 0));

            LOG_FMT(LOUTIND, "  %d> col %d/%d - ", pc->orig_line, pc->column, cpd.column);
         }
         else
         {
            /* not the first item on a line */
            if (cpd.settings[UO_align_keep_tabs].b)
            {
               allow_tabs = pc->after_tab;
            }
            else
            {
               prev       = chunk_get_prev(pc);
               allow_tabs = (cpd.settings[UO_align_with_tabs].b &&
                             ((pc->flags & PCF_WAS_ALIGNED) != 0) &&
                             (((pc->column - 1) % cpd.settings[UO_output_tab_size].n) == 0) &&
                             ((prev->column + prev->len + 1) != pc->column));
            }
            LOG_FMT(LOUTIND, " %d -", pc->column);
         }

         output_to_column(pc->column, allow_tabs);
         add_text_len(pc->str, pc->len);
         cpd.did_newline = chunk_is_newline(pc);
      }
   }
}


/**
 * Given a multi-line comemnt block that starts in column X, figure out how
 * much subsequent lines should be indented.
 *
 * The answer is either 0 or 1.
 *
 * The decision is based on:
 *  - the first line length
 *  - the second line leader length
 *  - the last line length
 *
 * If the first and last line are the same length and don't contain any alnum
 * chars and (the first line len > 2 or the second leader is the same as the
 * first line length), then the indent is 0.
 *
 * If the leader on the second line is 1 wide or missing, then the indent is 1.
 *
 * Otherwise, the indent is 0.
 *
 * @param str       The comment string
 * @param len       Length of the comment
 * @param start_col Starting column
 * @return 0 or 1
 */
static int calculate_comment_body_indent(const char *str, int len, int start_col)
{
   int idx       = 0;
   int first_len = 0;
   int last_len  = 0;
   int width     = 0;

   /* find the last line length */
   for (idx = len - 1; idx > 0; idx--)
   {
      if ((str[idx] == '\n') || (str[idx] == '\r'))
      {
         idx++;
         while ((idx < len) && ((str[idx] == ' ') || (str[idx] == '\t')))
         {
            idx++;
         }
         last_len = len - idx;
         break;
      }
   }

   /* find the first line length */
   for (idx = 0; idx < len; idx++)
   {
      if ((str[idx] == '\n') || (str[idx] == '\r'))
      {
         first_len = idx;
         while ((str[first_len - 1] == ' ') || (str[first_len - 1] == '\t'))
         {
            first_len--;
         }

         /* handle DOS endings */
         if ((str[idx] == '\r') && (str[idx + 1] == '\n'))
         {
            idx++;
         }
         idx++;
         break;
      }
   }

   /* Scan the second line */
   width = 0;
   for ( /* nada */; idx < len; idx++)
   {
      if ((str[idx] == ' ') || (str[idx] == '\t'))
      {
         if (width > 0)
         {
            break;
         }
         continue;
      }
      if ((str[idx] == '\n') || (str[idx] == '\r'))
      {
         /* Done with second line */
         break;
      }

      /* Count the leading chars */
      if ((str[idx] == '*') ||
          (str[idx] == '|') ||
          (str[idx] == '\\') ||
          (str[idx] == '#') ||
          (str[idx] == '+'))
      {
         width++;
      }
      else
      {
         break;
      }
   }

   //LOG_FMT(LSYS, "%s: first=%d last=%d width=%d\n", __func__, first_len, last_len, width);

   /*TODO: make the first_len minimum (4) configurable? */
   if ((first_len == last_len) && ((first_len > 4) || first_len == width))
   {
      return(0);
   }

   return((width == 2) ? 0 : 1);
}

static_inline void add_spaces_before_star()
{
   int count = cpd.settings[UO_cmt_sp_before_star_cont].n;
   while (count-- > 0)
   {
      add_char(' ');
   }
}

static_inline void add_spaces_after_star()
{
   if (cpd.settings[UO_cmt_star_cont].b)
   {
      int count = cpd.settings[UO_cmt_sp_after_star_cont].n;
      while (count-- > 0)
      {
         add_char(' ');
      }
   }
}

/**
 * adds the body of the C comment, inserting a space inside any embedded
 * C comment closures... "* /"
 */
static void add_converted_comment(chunk_t *pc)
{
   for (int idx = 2; idx < pc->len; idx++)
   {
      add_char(pc->str[idx]);
      if ((pc->str[idx] == '*') && (pc->str[idx + 1] == '/'))
      {
         add_char(' ');
      }
   }
}

/**
 * Outputs the CPP comment at pc.
 * CPP comment combining is done here
 *
 * @return the last chunk output'd
 */
00444 chunk_t *output_comment_cpp(chunk_t *first)
{
   int col    = first->column;
   int col_br = first->column_indent;

   /* Make sure we have at least one space past the last token */
   if (first->parent_type == CT_COMMENT_END)
   {
      chunk_t *prev = chunk_get_prev(first);
      if (prev != NULL)
      {
         int col_min = prev->column + prev->len + 1;
         if (col < col_min)
         {
            col = col_min;
         }
      }
   }

   /* Bump out to the column */
   output_indent(col, col_br);

   if (!cpd.settings[UO_cmt_cpp_to_c].b)
   {
      add_text_len(first->str, first->len);
      return(first);
   }

   /* If we are grouping, see if there is something to group */
   bool combined = false;
   if (cpd.settings[UO_cmt_cpp_group].b)
   {
      /* next is a newline by definition */
      chunk_t *next = chunk_get_next(first);
      if ((next != NULL) && (next->nl_count == 1))
      {
         next = chunk_get_next(next);

         /**
          * Only combine the next comment if they are both at indent level or
          * the second one is NOT at indent or less
          *
          * A trailing comment cannot be combined with a comment at indent
          * level or less
          */
         if ((next != NULL) &&
             (next->type == CT_COMMENT_CPP) &&
             (((next->column == 1) && (first->column == 1)) ||
              ((next->column == col_br) && (first->column == col_br)) ||
              ((next->column > col_br) && (first->parent_type == CT_COMMENT_END))))
         {
            combined = true;
         }
      }
   }

   if (!combined)
   {
      /* nothing to group: just output a single line */
      add_text_len("/*", 2);
      if ((first->str[2] != ' ') && (first->str[2] != '\t'))
      {
         add_char(' ');
      }
      add_converted_comment(first);
      add_text_len(" */", 3);
      return(first);
   }

   chunk_t *pc   = first;
   chunk_t *last = first;

   /* Output the first line */
   add_text_len("/*", 2);
   if (combined && cpd.settings[UO_cmt_cpp_nl_start].b)
   {
      /* I suppose someone more clever could do this without a goto or
       * repeating too much code...
       */
      goto cpp_newline;
   }
   goto cpp_addline;

   /* Output combined lines */
   while ((pc = chunk_get_next(pc)) != NULL)
   {
      if ((pc->type == CT_NEWLINE) && (pc->nl_count == 1))
      {
         continue;
      }
      if (pc->type != CT_COMMENT_CPP)
      {
         break;
      }
      if (((pc->column == 1) && (first->column == 1)) ||
          ((pc->column == col_br) && (first->column == col_br)) ||
          ((pc->column > col_br) && (first->parent_type == CT_COMMENT_END)))
      {
         last = pc;

cpp_newline:
         add_char('\n');
         output_indent(col, col_br);
         add_char(' ');
         add_spaces_before_star();
         add_char(cpd.settings[UO_cmt_star_cont].b ? '*' : ' ');
         add_spaces_after_star();

cpp_addline:
         if ((pc->str[2] != ' ') && (pc->str[2] != '\t'))
         {
            add_char(' ');
         }
         add_converted_comment(pc);
      }
   }

   if (cpd.settings[UO_cmt_cpp_nl_end].b)
   {
      add_char('\n');
      output_indent(col, col_br);
   }
   add_text_len(" */", 3);
   return(last);
}

void output_comment_multi(chunk_t *pc)
{
   int        cmt_col = pc->column;
   const char *cmt_str;
   int        remaining;
   char       ch;
   chunk_t    *prev;
   char       line[1024];
   int        line_len;
   int        line_count = 0;
   int        ccol;
   int        col_diff = 0;
   int        xtra     = 1;

   prev = chunk_get_prev(pc);
   if ((prev != NULL) && (prev->type != CT_NEWLINE))
   {
      cmt_col = pc->orig_col;
   }
   else
   {
      col_diff = pc->orig_col - pc->column;
   }

   //   fprintf(stderr, "Indenting1 line %d to col %d (orig=%d) col_diff=%d\n",
   //           pc->orig_line, cmt_col, pc->orig_col, col_diff);

   xtra = calculate_comment_body_indent(pc->str, pc->len, pc->column);

   ccol      = 1;
   remaining = pc->len;
   cmt_str   = pc->str;
   line_len  = 0;
   while (remaining > 0)
   {
      ch = *cmt_str;
      cmt_str++;
      remaining--;

      /* handle the CRLF and CR endings. convert both to LF */
      if (ch == '\r')
      {
         ch = '\n';
         if (*cmt_str == '\n')
         {
            cmt_str++;
            remaining--;
         }
      }

      /* Find the start column */
      if (line_len == 0)
      {
         if (ch == ' ')
         {
            ccol++;
            continue;
         }
         else if (ch == '\t')
         {
            ccol = calc_next_tab_column(ccol, cpd.settings[UO_input_tab_size].n);
            continue;
         }
         else
         {
            //fprintf(stderr, "%d] Text starts in col %d\n", line_count, ccol);
         }
      }

      line[line_len++] = ch;

      /* If we just hit an end of line OR we just hit end-of-comment... */
      if ((ch == '\n') || (remaining == 0))
      {
         line_count++;

         /* strip trailing tabs and spaces before the newline */
         if (ch == '\n')
         {
            line_len--;
            while ((line_len > 0) &&
                   ((line[line_len - 1] == ' ') ||
                    (line[line_len - 1] == '\t')))
            {
               line_len--;
            }
            line[line_len++] = ch;
         }
         line[line_len] = 0;

         if (line_count == 1)
         {
            /* this is the first line - add unchanged */

            /*TODO: need to support indent_with_tabs mode 1 */
            output_to_column(cmt_col, cpd.settings[UO_indent_with_tabs].b);
            add_text_len(line, line_len);
         }
         else
         {
            /* This is not the first line, so we need to indent to the
             * correct column.
             */
            ccol -= col_diff;
            if (ccol < cmt_col)
            {
               ccol = cmt_col;
            }

            if (line[0] == '\n')
            {
               /* Emtpy line - just a '\n' */
               if (cpd.settings[UO_cmt_star_cont].b)
               {
                  output_to_column(cmt_col, cpd.settings[UO_indent_with_tabs].b);
                  add_spaces_before_star();
                  add_text((xtra == 1) ? " *" : "*");
                  add_spaces_after_star();
               }
               add_char('\n');
            }
            else
            {
               add_spaces_before_star();

               /* If this doesn't start with a '*' or '|' */
               if ((line[0] != '*') && (line[0] != '|') && (line[0] != '#') &&
                   (line[0] != '\\') && (line[0] != '+'))
               {
                  output_to_column(cmt_col, cpd.settings[UO_indent_with_tabs].b);
                  if (cpd.settings[UO_cmt_star_cont].b)
                  {
                     add_text((xtra == 1) ? " * " : "*  ");
                     add_spaces_after_star();
                  }
                  else
                  {
                     add_text("   ");
                  }
                  output_to_column(ccol, cpd.settings[UO_indent_with_tabs].b);
               }
               else
               {
                  output_to_column(cmt_col + xtra, cpd.settings[UO_indent_with_tabs].b);
               }
               add_text_len(line, line_len);
            }
         }
         line_len = 0;
         ccol     = 1;
      }
   }
}

Generated by  Doxygen 1.6.0   Back to index