home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / utilities / utilsf / indent / Source / c / pr_comment < prev   
Text File  |  1995-10-27  |  12KB  |  422 lines
  1. /*
  2.  * Copyright (c) 1985 Sun Microsystems, Inc.
  3.  * Copyright (c) 1980 The Regents of the University of California.
  4.  * Copyright (c) 1976 Board of Trustees of the University of Illinois.
  5.  * All rights reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms are permitted
  8.  * provided that the above copyright notice and this paragraph are
  9.  * duplicated in all such forms and that any documentation,
  10.  * advertising materials, and other materials related to such
  11.  * distribution and use acknowledge that the software was developed
  12.  * by the University of California, Berkeley, the University of Illinois,
  13.  * Urbana, and Sun Microsystems, Inc.  The name of either University
  14.  * or Sun Microsystems may not be used to endorse or promote products
  15.  * derived from this software without specific prior written permission.
  16.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19.  */
  20.  
  21. /* Archimedes port by Steven Flintham
  22.    Wednesday 25th October 1995
  23.    Friday 27th October 1995 */
  24.  
  25. #ifndef lint
  26. static char sccsid[] = "@(#)pr_comment.c    5.9 (Berkeley) 9/15/88";
  27. #endif /* not lint */
  28.  
  29. /*
  30.  * NAME:
  31.  *    pr_comment
  32.  *
  33.  * FUNCTION:
  34.  *    This routine takes care of scanning and printing comments.
  35.  *
  36.  * ALGORITHM:
  37.  *    1) Decide where the comment should be aligned, and if lines should
  38.  *       be broken.
  39.  *    2) If lines should not be broken and filled, just copy up to end of
  40.  *       comment.
  41.  *    3) If lines should be filled, then scan thru input_buffer copying
  42.  *       characters to com_buf.  Remember where the last blank, tab, or
  43.  *       newline was.  When line is filled, print up to last blank and
  44.  *       continue copying.
  45.  *
  46.  * HISTORY:
  47.  *    November 1976    D A Willcox of CAC    Initial coding
  48.  *    12/6/76        D A Willcox of CAC    Modification to handle
  49.  *                        UNIX-style comments
  50.  *
  51.  */
  52.  
  53. /*
  54.  * this routine processes comments.  It makes an attempt to keep comments from
  55.  * going over the max line length.  If a line is too long, it moves everything
  56.  * from the last blank to the next comment line.  Blanks and tabs from the
  57.  * beginning of the input line are removed
  58.  */
  59.  
  60. #ifndef __riscos /* SF */
  61. #include "indent_globs.h"
  62. #else
  63. #include "indntglobs.h"
  64. #endif /* __riscos */
  65.  
  66.  
  67. pr_comment()
  68. {
  69.     int         now_col;    /* column we are in now */
  70.     int         adj_max_col;    /* Adjusted max_col for when we decide to
  71.                  * spill comments over the right margin */
  72.     char       *last_bl;    /* points to the last blank in the output
  73.                  * buffer */
  74.     char       *t_ptr;        /* used for moving string */
  75.     int         unix_comment;    /* tri-state variable used to decide if it is
  76.                  * a unix-style comment. 0 means only blanks
  77.                  * since /*, 1 means regular style comment, 2
  78.                  * means unix style comment */
  79.     int         break_delim = comment_delimiter_on_blankline;
  80.     int         l_just_saw_decl = ps.just_saw_decl;
  81.     /*
  82.      * int         ps.last_nl = 0;    /* true iff the last significant thing
  83.      * weve seen is a newline
  84.      */
  85.     int         one_liner = 1;    /* true iff this comment is a one-liner */
  86.     adj_max_col = max_col;
  87.     ps.just_saw_decl = 0;
  88.     last_bl = 0;        /* no blanks found so far */
  89.     ps.box_com = false;        /* at first, assume that we are not in
  90.                      * a boxed comment or some other
  91.                      * comment that should not be touched */
  92.     ++ps.out_coms;        /* keep track of number of comments */
  93.     unix_comment = 1;        /* set flag to let us figure out if there is a
  94.                  * unix-style comment ** DISABLED: use 0 to
  95.                  * reenable this hack! */
  96.  
  97.     /* Figure where to align and how to treat the comment */
  98.  
  99.     if (ps.col_1 && !format_col1_comments) {    /* if comment starts in column
  100.                          * 1 it should not be touched */
  101.     ps.box_com = true;
  102.     ps.com_col = 1;
  103.     }
  104.     else {
  105.     if (*buf_ptr == '-' || *buf_ptr == '*') {
  106.         ps.box_com = true;    /* a comment with a '-' or '*' immediately
  107.                  * after the /* is assumed to be a boxed
  108.                  * comment */
  109.         break_delim = 0;
  110.     }
  111.     if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) {
  112.         /* klg: check only if this line is blank */
  113.         /*
  114.          * If this (*and previous lines are*) blank, dont put comment way
  115.          * out at left
  116.          */
  117.         ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
  118.         adj_max_col = block_comment_max_col;
  119.         if (ps.com_col <= 1)
  120.         ps.com_col = 1 + !format_col1_comments;
  121.     }
  122.     else {
  123.         register    target_col;
  124.         break_delim = 0;
  125.         if (s_code != e_code)
  126.         target_col = count_spaces(compute_code_target(), s_code);
  127.         else {
  128.         target_col = 1;
  129.         if (s_lab != e_lab)
  130.             target_col = count_spaces(compute_label_target(), s_lab);
  131.         }
  132.         ps.com_col = ps.decl_on_line || ps.ind_level == 0 ? ps.decl_com_ind : ps.com_ind;
  133.         if (ps.com_col < target_col)
  134.         ps.com_col = ((target_col + 7) & ~7) + 1;
  135.         if (ps.com_col + 24 > adj_max_col)
  136.         adj_max_col = ps.com_col + 24;
  137.     }
  138.     }
  139.     if (ps.box_com) {
  140.     buf_ptr[-2] = 0;
  141.     ps.n_comment_delta = 1 - count_spaces(1, in_buffer);
  142.     buf_ptr[-2] = '/';
  143.     }
  144.     else {
  145.     ps.n_comment_delta = 0;
  146.     while (*buf_ptr == ' ' || *buf_ptr == '\t')
  147.         buf_ptr++;
  148.     }
  149.     ps.comment_delta = 0;
  150.     *e_com++ = '/';        /* put '/*' into buffer */
  151.     if (ps.cc_comment)        /*  (or '//') */
  152.     *e_com++ = '/';
  153.     else
  154.     *e_com++ = '*';
  155.     if (*buf_ptr != ' ' && !ps.box_com)
  156.     *e_com++ = ' ';
  157.  
  158.     *e_com = '\0';
  159.     if (troff) {
  160.     now_col = 1;
  161.     adj_max_col = 80;
  162.     }
  163.     else
  164.     now_col = count_spaces(ps.com_col, s_com);    /* figure what column we
  165.                              * would be in if we
  166.                              * printed the comment
  167.                              * now */
  168.  
  169.     /* Start to copy the comment */
  170.  
  171.     while (1) {            /* this loop will go until the comment is
  172.                  * copied */
  173.     if (*buf_ptr >= 040 && *buf_ptr != '*')
  174.         ps.last_nl = 0;
  175.     check_size(com);
  176.     switch (*buf_ptr) {    /* this checks for various spcl cases */
  177.     case 014:        /* check for a form feed */
  178.         if (!ps.box_com) {    /* in a text comment, break the line here */
  179.         ps.use_ff = true;
  180.         /* fix so dump_line uses a form feed */
  181.         dump_line();
  182.         last_bl = 0;
  183.         *e_com++ = ' ';
  184.         *e_com++ = '*';
  185.         *e_com++ = ' ';
  186.         while (*++buf_ptr == ' ' || *buf_ptr == '\t');
  187.         }
  188.         else {
  189.         if (++buf_ptr >= buf_end)
  190.             fill_buffer();
  191.         *e_com++ = 014;
  192.         }
  193.         break;
  194.  
  195.     case '\n':
  196.         if (ps.cc_comment) {
  197.         *e_com = '\0';
  198.         dump_line();
  199.         ps.cc_comment = 0;
  200.         ps.just_saw_decl = l_just_saw_decl; /* ?? */
  201.         if (++buf_ptr >= buf_end)    /* eat '\n' */
  202.             fill_buffer();
  203.         return;
  204.         }
  205.         if (had_eof) {    /* check for unexpected eof */
  206.         printf("Unterminated comment\n");
  207.         *e_com = '\0';
  208.         dump_line();
  209.         return;
  210.         }
  211.         one_liner = 0;
  212.         if (ps.box_com || ps.last_nl) {    /* if this is a boxed comment,
  213.                          * we dont ignore the newline */
  214.         if (s_com == e_com) {
  215.             *e_com++ = ' ';
  216.             *e_com++ = ' ';
  217.         }
  218.         *e_com = '\0';
  219.         if (!ps.box_com && e_com - s_com > 3) {
  220.             if (break_delim == 1 && s_com[0] == '/'
  221.                 && s_com[1] == '*' && s_com[2] == ' ') {
  222.             char       *t = e_com;
  223.             break_delim = 2;
  224.             e_com = s_com + 2;
  225.             *e_com = 0;
  226.             if (blanklines_before_blockcomments)
  227.                 prefix_blankline_requested = 1;
  228.             dump_line();
  229.             e_com = t;
  230.             s_com[0] = s_com[1] = s_com[2] = ' ';
  231.             }
  232.             dump_line();
  233.             check_size(com);
  234.             *e_com++ = ' ';
  235.             *e_com++ = ' ';
  236.         }
  237.         dump_line();
  238.         now_col = ps.com_col;
  239.         }
  240.         else {
  241.         ps.last_nl = 1;
  242.         if (unix_comment != 1) {    /* we not are in unix_style
  243.                          * comment */
  244.             if (unix_comment == 0 && s_code == e_code) {
  245.             /*
  246.              * if it is a UNIX-style comment, ignore the
  247.              * requirement that previous line be blank for
  248.              * unindention
  249.              */
  250.             ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
  251.             if (ps.com_col <= 1)
  252.                 ps.com_col = 2;
  253.             }
  254.             unix_comment = 2;    /* permanently remember that we are in
  255.                      * this type of comment */
  256.             dump_line();
  257.             ++line_no;
  258.             now_col = ps.com_col;
  259.             *e_com++ = ' ';
  260.             /*
  261.              * fix so that the star at the start of the line will line
  262.              * up
  263.              */
  264.             do        /* flush leading white space */
  265.             if (++buf_ptr >= buf_end)
  266.                 fill_buffer();
  267.             while (*buf_ptr == ' ' || *