home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / prog / utils / indent13.lha / indent-1.3 / pr_comment.c < prev    next >
C/C++ Source or Header  |  1992-05-03  |  14KB  |  446 lines
  1. /* Copyright (c) 1992, Free Software Foundation, Inc.  All rights reserved.
  2.  
  3.    Copyright (c) 1985 Sun Microsystems, Inc. Copyright (c) 1980 The Regents
  4.    of the University of California. Copyright (c) 1976 Board of Trustees of
  5.    the University of Illinois. All rights reserved.
  6.  
  7.    Redistribution and use in source and binary forms are permitted
  8.    provided that
  9.    the above copyright notice and this paragraph are duplicated in all such
  10.    forms and that any documentation, advertising materials, and other
  11.    materials related to such distribution and use acknowledge that the
  12.    software was developed by the University of California, Berkeley, the
  13.    University of Illinois, Urbana, and Sun Microsystems, Inc.  The name of
  14.    either University or Sun Microsystems may not be used to endorse or
  15.    promote products derived from this software without specific prior written
  16.    permission. THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17.    IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
  18.    OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. */
  19.  
  20. #ifndef lint
  21. static char sccsid[]= "@(#)pr_comment.c    5.9 (Berkeley) 9/15/88";
  22. #endif                /* not lint */
  23.  
  24. /* NAME: pr_comment
  25.  
  26. FUNCTION: This routine takes care of scanning and printing comments.
  27.  
  28. ALGORITHM: 1) Decide where the comment should be aligned, and if lines should
  29.    be broken. 2) If lines should not be broken and filled, just copy up to
  30.    end of comment. 3) If lines should be filled, then scan thru input_buffer
  31.    copying characters to com_buf.  Remember where the last blank, tab, or
  32.    newline was.  When line is filled, print up to last blank and continue
  33.    copying.
  34.  
  35. HISTORY: November 1976    D A Willcox of CAC    Initial coding 12/6/76
  36.     A Willcox of CAC    Modification to handle UNIX-style comments
  37.  
  38. */
  39.  
  40. /* this routine processes comments.  It makes an attempt to keep comments
  41.    from going over the max line length.  If a line is too long, it moves
  42.    everything from the last blank to the next comment line.  Blanks and tabs
  43.    from the beginning of the input line are removed */
  44.  
  45.  
  46. #include "sys.h"
  47. #include "indent.h"
  48.  
  49. /* Declared and documented in indent.h.  */
  50. int out_coms;
  51.  
  52. pr_comment ()
  53. {
  54.   int now_col;            /* column we are in now */
  55.   int adj_max_col;        /* Adjusted max_col for when we decide to
  56.                    spill comments over the right margin */
  57.   char *last_bl;        /* points to the last blank in the output
  58.                    buffer */
  59.   char *t_ptr;            /* used for moving string */
  60.   int unix_comment;        /* tri-state variable used to decide if it is
  61.                    a unix-style comment. 0 means only blanks
  62.                    since /*, 1 means regular style comment, 2
  63.                    means unix style comment */
  64.   int break_delim = comment_delimiter_on_blankline;
  65.   int l_just_saw_decl = parser_state_tos->just_saw_decl;
  66.   /* int         parser_state_tos->last_nl = 0;    /* true iff the last
  67.      significant thing weve seen is a newline */
  68.   int one_liner = 1;        /* true iff this comment is a one-liner */
  69.   adj_max_col = max_col;
  70.   parser_state_tos->just_saw_decl = 0;
  71.   last_bl = 0;            /* no blanks found so far */
  72.   parser_state_tos->box_com = false;    /* at first, assume that we are not
  73.                        in a boxed comment or some other
  74.                        comment that should not be touched */
  75.   ++out_coms;            /* keep track of number of comments */
  76.   unix_comment = 1;        /* set flag to let us figure out if there is
  77.                    a unix-style comment ** DISABLED: use 0 to
  78.                    reenable this hack! */
  79.  
  80.   /* Figure where to align and how to treat the comment */
  81.  
  82.   if (parser_state_tos->col_1 && !format_col1_comments)
  83.     {                /* if comment starts in column 1 it should
  84.                    not be touched */
  85.       parser_state_tos->box_com = true;
  86.       parser_state_tos->com_col = 1;
  87.     }
  88.   else
  89.     {
  90.       if (*buf_ptr == '-' || *buf_ptr == '*' || !format_comments)
  91.     {
  92.       parser_state_tos->box_com = true;    /* a comment with a '-' or
  93.                            '*' immediately after the
  94.                            /* is assumed to be a
  95.                            boxed comment */
  96.       break_delim = 0;
  97.     }
  98. #if 0
  99.       if (parser_state_tos->bl_line && (s_lab == e_lab) && (s_code == e_code))
  100. #endif
  101.       if ((s_lab == e_lab) && (s_code == e_code))
  102.     {
  103.       /* klg: check only if this line is blank */
  104.       /* If this (*and previous lines are*) blank, dont put comment way
  105.          out at left */
  106.       parser_state_tos->com_col = (parser_state_tos->ind_level - unindent_displace) + 1;
  107.       adj_max_col = block_comment_max_col;
  108.       if (parser_state_tos->com_col <= 1)
  109.         parser_state_tos->com_col = 1 + !format_col1_comments;
  110.  
  111.       /* If we have a comment in an old-style (pre-ANSI) parameter
  112.          declaration, indent it like we would the parameter declaration.
  113.          For example:
  114.            int destroy (what) / * N things to destroy.  * / int what;
  115.       */
  116.       if (parser_state_tos->in_parameter_declaration
  117.           && indent_parameters != 0
  118.           && parser_state_tos->dec_nest == 0)
  119.         {
  120.           parser_state_tos->com_col = indent_parameters + 1;
  121.           parser_state_tos->ind_stmt = 0;
  122.         }
  123.     }
  124.       else
  125.     {
  126.       register target_col;
  127.       break_delim = 0;
  128.       if (s_code != e_code)
  129.         target_col = count_spaces (compute_code_target (), s_code);
  130.       else
  131.         {
  132.           target_col = 1;
  133.           if (s_lab != e_lab)
  134.         target_col = count_spaces (compute_label_target (), s_lab);
  135.         }
  136.       parser_state_tos->com_col = parser_state_tos->decl_on_line || parser_state_tos->ind_level == 0 ? decl_com_ind : com_ind;
  137.       /* If we are already past the position for the comment, put it at
  138.          the next tab stop.  */
  139.       if (parser_state_tos->com_col < target_col)
  140.         parser_state_tos->com_col = ((target_col + 7) & ~7) + 1;
  141.       if (else_or_endif)
  142.         {
  143.           parser_state_tos->com_col = else_endif_col;
  144.           else_or_endif = false;
  145.           /* We want the comment to appear one space after the #else or
  146.              #endif.  */
  147.           if (parser_state_tos->com_col < target_col)
  148.         parser_state_tos->com_col = target_col + 1;
  149.         }
  150.       if (parser_state_tos->com_col + 24 > adj_max_col)
  151.         adj_max_col = parser_state_tos->com_col + 24;
  152.     }
  153.     }
  154.   if (parser_state_tos->box_com)
  155.     {
  156.       buf_ptr[-2] = 0;
  157.       parser_state_tos->n_comment_delta = 1 - count_spaces (1, cur_line);
  158.       buf_ptr[-2] = '/';
  159.     }
  160.   else
  161.     {
  162.       parser_state_tos->n_comment_delta = 0;
  163.       while (*buf_ptr == ' ' || *buf_ptr == '\t')
  164.     buf_ptr++;
  165.     }
  166.   parser_state_tos->comment_delta = 0;
  167.   *e_com++ = '/';        /* put '/*' into buffer */
  168.   *e_com++ = '*';
  169.   if (*buf_ptr != ' ' && !parser_state_tos->box_com)
  170.     *e_com++ = ' ';
  171.  
  172.   *e_com = '\0';
  173.   if (troff)
  174.     {
  175.       now_col = 1;
  176.       adj_max_col = 80;
  177.     }
  178.   else
  179.     now_col = count_spaces (parser_state_tos->com_col, s_com);    /* figure what column we
  180.                                    would be in if we
  181.                                    printed the comment
  182.                                    now */
  183.  
  184.   /* Start to copy the comment */
  185.  
  186.   while (1)
  187.     {                /* this loop will go until the comment is
  188.                    copied */
  189.       if (*buf_ptr > 040 && *buf_ptr != '*')
  190.     parser_state_tos->last_nl = 0;
  191.       check_com_size;
  192.       switch (*buf_ptr)
  193.     {            /* this checks for various spcl cases */
  194.     case 014:        /* check for a form feed */
  195.       if (!parser_state_tos->box_com)
  196.         {            /* in a text comment, break the line here */
  197.           parser_state_tos->use_ff = true;
  198.           /* fix so dump_line uses a form feed */
  199.           dump_line ();
  200.           last_bl = 0;
  201.           *e_com++ = ' ';
  202.           *e_com++ = '*';
  203.           *e_com++ = ' ';
  204.           while (*++buf_ptr == ' ' || *buf_ptr == '\t');
  205.         }
  206.       else
  207.         {
  208.           if (++buf_ptr >= buf_end)
  209.         fill_buffer ();
  210.           *e_com++ = 014;
  211.         }
  212.       break;
  213.  
  214.     case '\n':
  215.       if (had_eof)
  216.         {            /* check for unexpected eof */
  217.           printf ("Unterminated comment\n");
  218.           *e_com = '\0';
  219.           dump_line ();
  220.           return;
  221.         }
  222.       one_liner = 0;
  223.       if (parser_state_tos->box_com || parser_state_tos->last_nl)
  224.         {            /* if this is a boxed comment, we dont ignore
  225.                    the newline */
  226.           if (s_com == e_com)
  227.         {
  228.           *e_com++ = ' ';
  229.           *e_com++ = ' ';
  230.         }
  231.           *e_com = '\0';
  232.           if (!parser_state_tos->box_com && e_com - s_com > 3)
  233.         {
  234.           if (break_delim == 1 && s_com[0] == '/'
  235.               && s_com[1] == '*' && s_com[2] == ' ')
  236.             {
  237.               char *t = e_com;
  238.               break_delim = 2;
  239.               e_com = s_com + 2;
  240.               *e_com = 0;
  241.               if (blanklines_before_blockcomments)
  242.             prefix_blankline_requested = 1;
  243.               dump_line ();
  244.               e_com = t;
  245.               s_com[0] = s_com[1] = s_com[2] = ' ';
  246.             }
  247.           dump_line ();
  248.           check_com_size;
  249.           *e_com++ = ' ';
  250.           *e_com++ = ' ';
  251.         }
  252.           dump_line ();
  253.           now_col = parser_state_tos->com_col;
  254.         }
  255.       else
  256.         {
  257.           parser_state_tos->last_nl = 1;
  258.           if (unix_comment != 1)
  259.         {        /* we not are in unix_style comment */
  260.           if (unix_comment == 0 && s_code == e_code)
  261.             {
  262.               /* if it is a UNIX-style comment, ignore the
  263.                  requirement that previous line be blank for
  264.                  unindention */
  265.               parser_state_tos->com_col = ((parser_state_tos->ind_level - unindent_displace)
  266.                            + ind_size);
  267.               if (parser_state_tos->com_col <= 1)
  268.             parser_state_tos->com_col = 2;
  269.             }
  270.           unix_comment = 2;    /* permanently remember that we are
  271.                        in this type of comment */
  272.           dump_line ();
  273.           ++line_no;
  274.           now_col = parser_state_tos->com_col;
  275.           *e_com++ = ' ';
  276.           /* fix so that the star at the start of the line will line
  277.              up */
  278.           do        /* flush leading white space */
  279.             if (++buf_ptr >= buf_end)
  280.               fill_buffer ();
  281.           while (*buf_ptr == ' ' || *buf_ptr == '\t');
  282.           break;
  283.         }
  284.           if (*(e_com - 1) == ' ' || *(e_com - 1) == '\t')
  285.         last_bl = e_com - 1;
  286.           /* if there was a space at the end of the last line, remember
  287.              where it was */
  288.           else
  289.         {        /* otherwise, insert one */
  290.           last_bl = e_com;
  291.           check_com_size;
  292.           *e_com++ = ' ';
  293.           ++now_col;
  294.         }
  295.         }
  296.       ++line_no;        /* keep track of input line number */
  297.       if (!parser_state_tos->box_com)
  298.         {
  299.           int nstar = 1;
  300.           do
  301.         {        /* flush any blanks and/or tabs at start of
  302.                    next line */
  303.           if (++buf_ptr >= buf_end)
  304.             fill_buffer ();
  305.           if (*buf_ptr == '*' && --nstar >= 0)
  306.             {
  307.               if (++buf_ptr >= buf_end)
  308.             fill_buffer ();
  309.               if (*buf_ptr == '/')
  310.             goto end_of_comment;
  311.             }
  312.         }
  313.           while (*buf_ptr == ' ' || *buf_ptr == '\t');
  314.         }
  315.       else if (++buf_ptr >= buf_end)
  316.         fill_buffer ();
  317.       break;        /* end of case for newline */
  318.  
  319.     case '*':        /* must check for possibility of being at end
  320.                    of comment */
  321.       if (++buf_ptr >= buf_end)    /* get to next char after * */
  322.         fill_buffer ();
  323.  
  324.       if (unix_comment == 0)/* set flag to show we are not in unix-style
  325.                    comment */
  326.         unix_comment = 1;
  327.  
  328.       if (*buf_ptr == '/')
  329.         {            /* it is the end!!! */
  330.         end_of_comment:
  331.           if (++buf_ptr >= buf_end)
  332.         fill_buffer ();
  333.  
  334.           if (*(e_com - 1) != ' ' && !parser_state_tos->box_com)
  335.         {        /* insure blank before end */
  336.           *e_com++ = ' ';
  337.           ++now_col;
  338.         }
  339.           if (break_delim == 1 && !one_liner && s_com[0] == '/'
  340.           && s_com[1] == '*' && s_com[2] == ' ')
  341.         {
  342.           char *t = e_com;
  343.           break_delim = 2;
  344.           e_com = s_com + 2;
  345.           *e_com = 0;
  346.           if (blanklines_before_blockcomments)
  347.             prefix_blankline_requested = 1;
  348.           dump_line ();
  349.           e_com = t;
  350.           s_com[0] = s_com[1] = s_com[2] = ' ';
  351.         }
  352.           if (break_delim == 2 && e_com > s_com + 3
  353.           /* now_col > adj_max_col - 2 && !parser_state_tos->box_com */ )
  354.         {
  355.           *e_com = '\0';
  356.           dump_line ();
  357.           now_col = parser_state_tos->com_col;
  358.         }
  359.           check_com_size;
  360.           *e_com++ = '*';
  361.           *e_com++ = '/';
  362.           *e_com = '\0';
  363.           parser_state_tos->just_saw_decl = l_just_saw_decl;
  364.           return;
  365.         }
  366.       else
  367.         {            /* handle isolated '*' */
  368.           *e_com++ = '*';
  369.           ++now_col;
  370.         }
  371.       break;
  372.     default:        /* we have a random char */
  373.       if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t')
  374.         unix_comment = 1;    /* we are not in unix-style comment */
  375.  
  376.       *e_com = *buf_ptr++;
  377.       if (buf_ptr >= buf_end)
  378.         fill_buffer ();
  379.  
  380.       if (*e_com == '\t')    /* keep track of column */
  381.         now_col = now_col + tabsize - (now_col - 1) % tabsize;
  382.       else if (*e_com == '\b')    /* this is a backspace */
  383.         --now_col;
  384.       else
  385.         ++now_col;
  386.  
  387.       if (*e_com == ' ' || *e_com == '\t')
  388.         last_bl = e_com;
  389.       /* remember we saw a blank */
  390.  
  391.       ++e_com;
  392.       if (now_col > adj_max_col && !parser_state_tos->box_com && unix_comment == 1 && e_com[-1] > ' ')
  393.         {
  394.           /* the comment is too long, it must be broken up */
  395.           if (break_delim == 1 && s_com[0] == '/'
  396.           && s_com[1] == '*' && s_com[2] == ' ')
  397.         {
  398.           char *t = e_com;
  399.           break_delim = 2;
  400.           e_com = s_com + 2;
  401.           *e_com = 0;
  402.           if (blanklines_before_blockcomments)
  403.             prefix_blankline_requested = 1;
  404.           dump_line ();
  405.           e_com = t;
  406.           s_com[0] = s_com[1] = s_com[2] = ' ';
  407.         }
  408.           if (last_bl == 0)
  409.         {        /* we have seen no blanks */
  410.           last_bl = e_com;    /* fake it */
  411.           *e_com++ = ' ';
  412.         }
  413.           *e_com = '\0';    /* print what we have */
  414.           *last_bl = '\0';
  415.           while (last_bl > s_com && last_bl[-1] < 040)
  416.         *--last_bl = 0;
  417.           e_com = last_bl;
  418.           dump_line ();
  419.  
  420.           *e_com++ = ' ';    /* add blanks for continuation */
  421.           *e_com++ = ' ';
  422.           *e_com++ = ' ';
  423.  
  424.           t_ptr = last_bl + 1;
  425.           last_bl = 0;
  426.           if (t_ptr >= e_com)
  427.         {
  428.           while (*t_ptr == ' ' || *t_ptr == '\t')
  429.             t_ptr++;
  430.           while (*t_ptr != '\0')
  431.             {        /* move unprinted part of comment down in
  432.                    buffer */
  433.               if (*t_ptr == ' ' || *t_ptr == '\t')
  434.             last_bl = e_com;
  435.               *e_com++ = *t_ptr++;
  436.             }
  437.         }
  438.           *e_com = '\0';
  439.           now_col = count_spaces (parser_state_tos->com_col, s_com);    /* recompute current
  440.                                            position */
  441.         }
  442.       break;
  443.     }
  444.     }
  445. }
  446.