comments.c

代码格式化工具。 其实就是linux下indent的windows版本。

	  switch (*buf_ptr)
	    {
	    case ' ':
	    case TAB:
	      /* If formatting, and previous break marker is
	       * nonexistant, or before text on line, reset
	       * it to here. 
	       */
	      if (format && (line_break_ptr < text_on_line))
		{
		  line_break_ptr = e_com;
		}

	      if (format)
		{
		  /* Don't write two spaces after another, unless
		   * the first space is preceeded by a dot. */
		  if ((e_com == s_com) || (e_com[-1] != ' ') ||
		      (e_com - 1 == s_com) || (e_com[-2] == '.'))
		    {
		      *e_com++ = ' ';
		      column++;
		    }
		}
	      else if (*buf_ptr == ' ')
		{
		  *e_com++ = ' ';
		  column++;
		}
	      else
		{
		  /* Convert the tab to the appropriate number of spaces,
		     based on the column we found the comment in, not
		     the one we're printing in. */
		  int tab_width =
		    (settings.tabsize -
		     ((column + found_column - start_column -
		       1) % settings.tabsize));
		  column += tab_width;
		  while (tab_width--)
		    {
		      *e_com++ = ' ';
		    }
		}
	      break;

	    case EOL:
	      /* We may be at the end of a C++ comment */
	      if (comment_type == cplus_comment)
		{
		cplus_exit:
		  parser_state_tos->tos--;
		  parser_state_tos->com_col =
		    (two_contiguous_comments ? 1 : start_column);
		  parser_state_tos->box_com = boxed_comment;
		  *e_com = 0;
		  return;
		}

	      if (format)
		{
		  /* Newline and null are the two characters which
		     end an input line, so check here if we need to
		     get the next line. */
		  if (*buf_ptr == EOL)
		    {
		      ++line_no;
		    }

		  buf_ptr++;
		  if (buf_ptr >= buf_end)
		    {
		      fill_buffer ();
		    }

		  /* If there are any spaces between the text and this
		     newline character, remove them. */
		  if ((e_com > line_break_ptr) &&
		      (text_on_line < line_break_ptr))
		    {
		      e_com = line_break_ptr;
		    }

		  /* If this is "\n\n", or "\n<whitespace>\n",
		   * it's a paragraph break. */

		  skip_buffered_space ();	/* adjusts buf_ptr */

		  if ((*buf_ptr == EOL) || !text_on_line)
		    {
		      paragraph_break = 1;
		      goto end_line;
		    }

		  /* Also need to eat the preamble. */
		  if (!boxed_comment
		      && (current_column () == found_column + 1)
		      && (buf_ptr[0] == '*') && (buf_ptr[1] != '/'))
		    {
		      if (++buf_ptr >= buf_end)
			{
			  fill_buffer ();
			}

		      if ((*buf_ptr == ' ') && (++buf_ptr >= buf_end))
			{
			  fill_buffer ();
			}
		    }

		  /* This is a single newline.  Transform it (and any
		   * following whitespace) into a single blank. */

		  if (e_com[-1] != ' ')
		    {
		      line_break_ptr = e_com;
		      *e_com++ = ' ';
		      column++;
		    }

		  continue;
		}

	      /* We are printing this line "as is", so output it
	         and continue on to the next line. */
	      goto end_line;

	    case '*':
	      /* Check if we've reached the end of the comment. */
	      if (comment_type == comment)
		{
		  if (*(buf_ptr + 1) == '/')
		    {
		      /* If it's not a boxed comment, put some whitespace
		       * before the ending delimiter.  Otherwise, simply
		       * insert the delimiter. */

		      if (!boxed_comment)
			{
			  if (text_on_line)
			    {
			      if (blankline_delims && !suppress_cdb)
				{
				  *e_com = '\0';
				  dump_line (true, paren_targ);
				  *e_com++ = ' ';
				}
			      else
				{
				  /* Insert space before closing delim */
				  if ((*(e_com - 1) != ' ')
				      && (*(e_com - 1) != TAB))
				    {
				      *e_com++ = ' ';
				    }
				}
			    }
			  else if ((s_com == e_com) || (*s_com != '/'))
			    {
			      /* If no text on line, then line is completely empty
			       * or starts with preamble, or is beginning of
			       * comment and starts with beginning delimiter. */

			      e_com = s_com;
			      *e_com++ = ' ';
			    }
			  else
			    {
			      /* This is case of first comment line.  Test
			       * with:
			       * if (first_comment_line != com_lines)
			       * abort (); */

			      if ((*(e_com - 1) != ' ')
				  && (*(e_com - 1) != TAB))
				{
				  *e_com++ = ' ';
				}
			    }
			}

		      /* Now insert the ending delimiter */
		      *e_com++ = '*';
		      *e_com++ = '/';
		      *e_com = '\0';

		      /* Skip any whitespace following the comment.  If
		       * there is only whitespace after it, print the line.
		       *
		       * NOTE:  We're not printing the line: TRY IT! */

		      buf_ptr += 2;

		      buf_ptr = skip_horiz_space (buf_ptr);

		      if (buf_ptr >= buf_end)
			{
			  fill_buffer ();
			}

		      parser_state_tos->tos--;
		      parser_state_tos->com_col =
			(two_contiguous_comments ? 1 : start_column);
		      parser_state_tos->box_com = boxed_comment;
		      return;
		    }

		  /* If this star is on the second line of the
		   * comment in the same column as the star of the
		   * beginning delimiter, then consider it
		   * a boxed comment. */

		  if ((first_comment_line == com_lines - 1) &&
		      (e_com == s_com + line_preamble_length))
		    {
		      /* Account for change in line_preamble_length: */
		      column -= line_preamble_length - 1;
		      line_preamble = " ";
		      line_preamble_length = 1;
		      boxed_comment = 1;
		      format = 0;
		      blankline_delims = 0;
		      *s_com = ' ';
		      *(s_com + 1) = '*';
		      text_on_line = e_com = s_com + 2;
		      column++;
		      break;
		    }
		}

	      /* If it was not the end of the comment, drop through
	       * and insert the star on the line. */

	    default:
	      /* Some textual character. */
	      text_on_line = e_com;
	      *e_com++ = *buf_ptr;
	      column++;
	      break;
	    }


	  /* If we are formatting, check that we haven't exceeded the
	     line length.  If we haven't set line_break_ptr, keep going. */
	  if (format && (column > right_margin) && line_break_ptr)
	    {
	      if (line_break_ptr < e_com - 1)
		{
		  /* Here if we are really "breaking" the line:  the line
		   * break is before some text we've seen. */

		  *line_break_ptr = '\0';
		  save_ptr = line_break_ptr + 1;
		  save_length = e_com - save_ptr;
		  e_com = line_break_ptr;

		  /* If we had to go past `right_margin' to print stuff out,
		   * extend `right_margin' out to this point. */
		  if ((column - save_length) > right_margin)
		    {
		      right_margin = column - save_length;
		    }
		}
	      else
		{
		  /* The line break is after the last text;  we're really
		   * truncating the line. */
		  if (comment_type == cplus_comment)
		    {
		      buf_ptr = skip_horiz_space (buf_ptr);

		      buf_ptr--;
		      if (*buf_ptr == EOL)
			{
			  goto cplus_exit;
			}
		    }
		  else
		    {
		      while ((*buf_ptr == TAB) ||
			     (*buf_ptr == ' ') || (*buf_ptr == EOL))
			{
			  if (*buf_ptr == EOL)
			    {
			      ++line_no;
			    }

			  buf_ptr++;

			  if (buf_ptr >= buf_end)
			    {
			      fill_buffer ();
			    }
			}

		      buf_ptr--;
		    }

		  *e_com = EOS;
		}
	      goto end_line;
	    }

	  if (*buf_ptr == EOL)
	    {
	      ++line_no;
	    }

	  buf_ptr++;

	  if (buf_ptr == buf_end)
	    {
	      fill_buffer ();
	    }
	}


    end_line:
      /* Compress pure whitespace lines into newlines. */
      if (!text_on_line && !visible_preamble
	  && !(first_comment_line == com_lines))
	{
	  e_com = s_com;
	}

      *e_com = EOS;
      dump_line (true, paren_targ);

      /* We're in the middle of a C-comment, don't add blank lines! */

      prefix_blankline_requested = 0;

      /* If formatting (paragraph_break is only used for formatted
       * comments) and user wants blank lines merged, kill all white
       * space after the "\n\n" indicating a paragraph break. */

      if (paragraph_break)
	{
	  if (merge_blank_comment_lines)
	    {
	      while ((*buf_ptr == EOL) ||
		     (*buf_ptr == ' ') || (*buf_ptr == TAB))
		{
		  if (*buf_ptr == EOL)
		    {
		      ++line_no;
		    }

		  if (++buf_ptr >= buf_end)
		    {
		      fill_buffer ();
		    }
		}
	    }

	  paragraph_break = 0;
	}
      else
	{
	  /* If it was a paragraph break (`if' clause), we scanned ahead
	   * one character.  So, here in the `else' clause, advance buf_ptr. */

	  if (*buf_ptr == EOL)
	    {
	      ++line_no;
	    }

	  buf_ptr++;

	  if (buf_ptr >= buf_end)
	    {
	      fill_buffer ();
	    }
	}

    begin_line:
      if (had_eof)
	{
	  break;
	}

      /* Indent the line properly.  If it's a boxed comment, align with
       * the '*' in the beginning slash-star and start inserting there.
       * Otherwise, insert blanks for alignment, or a star if the
       * user specified -sc.
       */

      if (line_preamble)
	{
	  (void) memcpy (e_com, line_preamble, line_preamble_length);
	  e_com += line_preamble_length;
	  column = start_column + line_preamble_length;
	}
      else
	{
	  column = start_column;
	}

      line_break_ptr = 0;

      /* If we have broken the line before the end for formatting,
       * copy the text after the break onto the beginning of this
       * new comment line. */

      if (save_ptr)
	{
	  while (((*save_ptr == ' ') || (*save_ptr == TAB)) && save_length)
	    {
	      save_ptr++;
	      save_length--;
	    }

	  (void) memcpy (e_com, save_ptr, save_length);
	  text_on_line = e_com;
	  e_com += save_length;

	  /* We only break if formatting, in which cases there
	   * are no tabs, only spaces. */

	  column += save_length;
	  save_ptr = 0;
	  save_length = 0;
	}
      else
	{
	  skip_buffered_space ();	/* adjusts buf_ptr */

	  text_on_line = 0;
	}
    }

  parser_state_tos->tos--;
  parser_state_tos->com_col = (two_contiguous_comments ? 1 : start_column);
  parser_state_tos->box_com = boxed_comment;
}