home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / jove-4.16-src.tgz / tar.out / bsd / jove / paragraph.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  15KB  |  577 lines
  1. /************************************************************************
  2.  * This program is Copyright (C) 1986-1996 by Jonathan Payne.  JOVE is  *
  3.  * provided to you without charge, and with no warranty.  You may give  *
  4.  * away copies of JOVE, including sources, provided that this notice is *
  5.  * included in all the files.                                           *
  6.  ************************************************************************/
  7.  
  8. #include "jove.h"
  9. #include "jctype.h"
  10. #include "disp.h"
  11. #include "delete.h"
  12. #include "insert.h"
  13. #include "fmt.h"
  14. #include "marks.h"
  15. #include "misc.h"
  16. #include "move.h"
  17. #include "paragraph.h"
  18. #include "re.h"
  19.  
  20. private int    get_indent proto((LinePtr));
  21.  
  22. /* Thanks to Brian Harvey for this paragraph boundary finding algorithm.
  23.    It's really quite hairy figuring it out.  This deals with paragraphs that
  24.    are seperated by blank lines, lines beginning with a Period (assumed to
  25.    be an nroff command), lines beginning with BackSlash (assumed to be Tex
  26.    commands).  Also handles paragraphs that are separated by lines of
  27.    different indent; and it deals with outdented paragraphs, too.  It's
  28.    really quite nice.  Here's Brian's algorithm.
  29.  
  30.    Definitions:
  31.  
  32.    THIS means the line containing the cursor.
  33.    PREV means the line above THIS.
  34.    NEXT means the line below THIS.
  35.  
  36.    BLANK means empty, empty except for spaces and tabs, starts with a period
  37.    or a backslash, or nonexistent (because the edge of the buffer is
  38.    reached).  ((BH 12/24/85 A line starting with backslash is blank only if
  39.    the following line also starts with backslash.  This is so that \noindent
  40.    is part of a paragraph, but long strings of TeX commands don't get
  41.    rearranged.  It still isn't perfect but it's better.))
  42.  
  43.    BSBLANK means BLANK or starts with a backslash.  (BH 12/24/85)
  44.  
  45.    HEAD means the first (nonblank) line of the paragraph containing THIS.
  46.    BODY means all other (nonblank) lines of the paragraph.
  47.    TAIL means the last (nb) line of the paragraph.  (TAIL is part of BODY.)
  48.  
  49.    HEAD INDENT means the indentation of HEAD.  M-J should preserve this.
  50.    BODY INDENT means the indentation of BODY.  Ditto.
  51.  
  52.    Subprocedures:
  53.  
  54.    TAILRULE(BODYLINE)
  55.    If BODYLINE is BLANK, the paragraph has only one line, and there is no
  56.    BODY and therefore no TAIL.  Return.  Otherwise, starting from BODYLINE,
  57.    move down until you find a line that either is BSBLANK or has a different
  58.    indentation from BODYLINE.  The line above that different line is TAIL.
  59.    Return.
  60.  
  61.    Rules:
  62.  
  63.    1.  If THIS is BLANK, which command are you doing?  If M-J or M-[, then go
  64.    up to the first non-BLANK line and start over.  (If there is no non-BLANK
  65.    line before THIS, ring the bell.)  If M-], then the first non-BLANK line
  66.    below THIS is HEAD, and the second consecutive non-BSBLANK line (if any) is
  67.    the beginning of BODY.  (If there is no non-BLANK line after THIS, ring
  68.    the bell.)  Do TAILRULE(beginning-of-BODY).  Go to rule A.
  69.  
  70.    2.  If PREV is BLANK or THIS is BSBLANK, then THIS is HEAD, and NEXT (if
  71.    not BSBLANK) is in BODY.  Do TAILRULE(NEXT).  Go to rule A.
  72.  
  73.    3.  If NEXT is BSBLANK, then THIS is TAIL, therefore part of BODY.  Go to
  74.    rule 5 to find HEAD.
  75.  
  76.    4.  If either NEXT or PREV has the same indentation as THIS, then THIS is
  77.    part of BODY.  Do TAILRULE(THIS).  Go to rule 5 to find HEAD.  Otherwise,
  78.    go to rule 6.
  79.  
  80.    5.  Go up until you find a line that is either BSBLANK or has a different
  81.    indentation from THIS.  If that line is BLANK, the line below it is HEAD;
  82.    If that line is non-BLANK, then call that new line THIS for what follows.
  83.    If THIS is BSBLANK (that is, THIS starts with backslash), THIS is HEAD;
  84.    otherwise, if (the new) PREV has the same indent as THIS, then (the new)
  85.    NEXT is HEAD; if PREV has a different indent from THIS, then THIS is
  86.    HEAD.  Go to rule A.
  87.  
  88.    6.  If you got here, then both NEXT and PREV are nonblank and are
  89.    differently indented from THIS.  This is a tricky case and there is no
  90.    guarantee that you're going to win.  The most straightforward thing to do
  91.    is assume that we are not using hanging indentation.  In that case:
  92.    whichever of PREV and THIS is indented further is HEAD.  Do
  93.    TAILRULE(HEAD+1).  Go to rule A.
  94.  
  95.    6+.  A more complicated variant would be this: if THIS is indented further
  96.    than PREV, we are using regular indentation and rule 6 applies.  If PREV
  97.    is indented further than THIS, look at both NEXT and the line after NEXT.
  98.    If those two lines are indented equally, and more than THIS, then we are
  99.    using hanging indent, THIS is HEAD, and NEXT is the first line of BODY.
  100.    Do TAILRULE(NEXT).  Otherwise, rule 6 applies.
  101.  
  102.    A.  You now know where HEAD and TAIL are.  The indentation of HEAD is HEAD
  103.    INDENT; the indentation of TAIL is BODY INDENT.
  104.  
  105.    B.  If you are trying to M-J, you are now ready to do it.
  106.  
  107.    C.  If you are trying to M-], leave point after the newline that ends
  108.    TAIL.  In other words, leave the cursor at the beginning of the line
  109.    after TAIL.  It is not possible for this to leave point where it started
  110.    unless it was already at the end of the buffer.
  111.  
  112.    D.  If you are trying to M-[, if the line before HEAD is not BLANK, then
  113.    leave point just before HEAD.  That is, leave the cursor at the beginning
  114.    of HEAD.  If the line before HEAD is BLANK, then leave the cursor at the
  115.    beginning of that line.  If the cursor didn't move, go up to the first
  116.    earlier non-BLANK line and start over.
  117.  
  118.  
  119.    End of Algorithm.  I implemented rule 6+ because it seemed nicer.  */
  120.  
  121. bool
  122.     SpaceSent2 = YES;    /* VAR: space-sentence-2 */
  123.  
  124. int
  125.     LMargin = 0,    /* VAR: left margin */
  126.     RMargin = 78;    /* VAR: right margin */
  127.  
  128. char
  129.     ParaDelim[sizeof(ParaDelim)] = "[ \t]*$\\|\\.\\|\\\\";    /* VAR: paragraph-delimiter-pattern */
  130.  
  131. private LinePtr
  132.     para_head,
  133.     para_tail;
  134.  
  135. private int
  136.     head_indent,
  137.     body_indent;
  138.  
  139. private bool    use_lmargin;
  140.  
  141. /* some defines for paragraph boundary checking */
  142. #define I_DELIM        (-1)    /* line matched by paragraph-delimiter-pattern */
  143. #define I_BUFEDGE    (-2)    /* line is nonexistent (edge of buffer) */
  144.  
  145. private bool    bslash;        /* Nonzero if get_indent finds line starting
  146.                    with backslash */
  147.  
  148. private bool
  149. i_blank(lp)
  150. LinePtr    lp;
  151. {
  152.     return get_indent(lp) < 0;
  153. }
  154.  
  155. private bool
  156. i_bsblank(lp)
  157. LinePtr    lp;
  158. {
  159.     return i_blank(lp) || bslash;
  160. }
  161.  
  162. private int
  163. get_indent(lp)
  164. register LinePtr    lp;
  165. {
  166.     Bufpos    save;
  167.     register int    indent;
  168.  
  169.     bslash = NO;
  170.     if (lp == NULL)
  171.         return I_BUFEDGE;
  172.     DOTsave(&save);
  173.     SetLine(lp);
  174.     if (LookingAt(ParaDelim, linebuf, 0)) {
  175.         indent = I_DELIM;
  176.         if (linebuf[0] == '\\' && REeom == 1) {
  177.             /* BH 12/24/85.  Backslash is delimiter only if next line
  178.                also starts with Backslash. */
  179.             bslash = YES;
  180.             SetLine(lp->l_next);
  181.             if (linebuf[0] != '\\')
  182.                 indent = 0;
  183.         }
  184.     } else {
  185.         ToIndent();
  186.         indent = calc_pos(linebuf, curchar);
  187.     }
  188.     SetDot(&save);
  189.  
  190.     return indent;
  191. }
  192.  
  193. private LinePtr
  194. tailrule(lp)
  195. register LinePtr    lp;
  196. {
  197.     int    i;
  198.  
  199.     i = get_indent(lp);
  200.     if (i < 0)
  201.         return lp;    /* one line paragraph */
  202.     do {
  203.         if ((get_indent(lp->l_next) != i) || bslash)
  204.             /* BH line with backslash is head of next para */
  205.             break;
  206.     } while ((lp = lp->l_next) != NULL);
  207.     if (lp == NULL)
  208.         complain((char *) NULL);
  209.     return lp;
  210. }
  211.  
  212. /* Finds the beginning, end and indent of the current paragraph, and sets
  213.    the above global variables.  HOW says how to behave when we're between
  214.    paragraphs.  That is, it's either FORWARD or BACKWARD depending on which
  215.    way we're favoring. */
  216.  
  217. private void
  218. find_para(how)
  219. int    how;
  220. {
  221.     LinePtr    this,
  222.         prev,
  223.         next,
  224.         head = NULL,
  225.         body = NULL,
  226.         tail = NULL;
  227.     int    this_indent;
  228.     Bufpos    orig;        /* remember where we were when we started */
  229.  
  230.     DOTsave(&orig);
  231. strt:
  232.     this = curline;
  233.     prev = curline->l_prev;
  234.     next = curline->l_next;
  235.     this_indent = get_indent(this);
  236.  
  237.     if (i_blank(this)) {        /* rule 1 */
  238.         if (how == BACKWARD) {
  239.             while (i_blank(curline))
  240.                 if (firstp(curline))
  241.                     complain((char *)NULL);
  242.                 else
  243.                     line_move(BACKWARD, 1, NO);
  244.             goto strt;
  245.         } else {
  246.             while (i_blank(curline))
  247.                 if (lastp(curline))
  248.                     complain((char *)NULL);
  249.                 else
  250.                     line_move(FORWARD, 1, NO);
  251.             head = curline;
  252.             next = curline->l_next;
  253.             body = !i_bsblank(next)? next : head;
  254.         }
  255.     } else if (i_bsblank(this) || i_blank(prev)) {    /* rule 2 */
  256.         head = this;
  257.         if (!i_bsblank(next))
  258.             body = next;
  259.     } else if (i_bsblank(next)) {    /* rule 3 */
  260.         tail = this;
  261.         body = this;
  262.     } else if ((get_indent(next) == this_indent) ||    /* rule 4 */
  263.            (get_indent(prev) == this_indent)) {
  264.         body = this;
  265.     } else {        /* rule 6+ */
  266.         if (get_indent(prev) > this_indent) {
  267.             /* hanging indent maybe? */
  268.             if (next != NULL
  269.             && get_indent(next) == get_indent(next->l_next))
  270.             {
  271.                 head = this;
  272.                 body = next;
  273.             }
  274.         }
  275.         /* Now we handle hanging indent else and the other
  276.            case of this_indent > get_indent(prev).  That is,
  277.            if we didn't resolve HEAD in the above if, then
  278.            we are not a hanging indent. */
  279.         if (head == NULL) {    /* still don't know */
  280.             head =  this_indent > get_indent(prev)? this : prev;
  281.             body = head->l_next;
  282.         }
  283.     }
  284.     /* rule 5 -- find the missing parts */
  285.     if (head == NULL) {    /* haven't found head of paragraph so do so now */
  286.         LinePtr    lp;
  287.         int    i;
  288.  
  289.         lp = this;
  290.         do {
  291.             i = get_indent(lp->l_prev);
  292.             if (i < 0)    /* is blank */
  293.                 head = lp;
  294.             else if (bslash)
  295.                 head = lp->l_prev;
  296.             else if (i != this_indent) {
  297.                 this = lp->l_prev;
  298.                 if (get_indent(this->l_prev) == i)
  299.                     head = this->l_next;
  300.                 else
  301.                     head = this;
  302.             }
  303.         } while (head == NULL && (lp = lp->l_prev) != NULL);
  304.         if (lp == NULL)
  305.             complain((char *)NULL);
  306.     }
  307.     if (body == NULL)        /* this must be a one line paragraph */
  308.         body = head;
  309.     if (tail == NULL)
  310.         tail = tailrule(body);
  311.     if (tail == NULL || head == NULL || body == NULL)
  312.         complain("BUG! tail(%d),head(%d),body(%d)!", tail, head, body);
  313.     para_head = head;
  314.     para_tail = tail;
  315.     head_indent = get_indent(head);
  316.     body_indent = get_indent(body);
  317.  
  318.     SetDot(&orig);
  319. }
  320.  
  321. void
  322. Justify()
  323. {
  324.     use_lmargin = is_an_arg();
  325.     find_para(BACKWARD);
  326.     DoJustify(para_head, 0, para_tail, length(para_tail), NO,
  327.           use_lmargin ? LMargin : body_indent);
  328. }
  329.  
  330. private LinePtr
  331. max_line(l1, l2)
  332. LinePtr    l1,
  333.     l2;
  334. {
  335.     return inorder(l1, 0, l2, 0)? l2 : l1;
  336. }
  337.  
  338. private LinePtr
  339. min_line(l1, l2)
  340. LinePtr    l1,
  341.     l2;
  342. {
  343.     return inorder(l1, 0, l2, 0)? l1 : l2;
  344. }
  345.  
  346. void
  347. RegJustify()
  348. {
  349.     Mark    *mp = CurMark(),
  350.         *tailmark;
  351.     LinePtr    l1 = curline,
  352.         l2 = mp->m_line;
  353.     int    c1 = curchar,
  354.         c2 = mp->m_char;
  355.     LinePtr    rl1,
  356.         rl2;
  357.  
  358.     use_lmargin = is_an_arg();
  359.     (void) fixorder(&l1, &c1, &l2, &c2);
  360.     do {
  361.         DotTo(l1, c1);
  362.         find_para(FORWARD);
  363.         rl1 = max_line(l1, para_head);
  364.         rl2 = min_line(l2, para_tail);
  365.         tailmark = MakeMark(para_tail, 0);
  366.         DoJustify(rl1, (rl1 == l1) ? c1 : 0, rl2,
  367.               (rl2 == l2) ? c2 : length(rl2),
  368.               NO, use_lmargin ? LMargin : body_indent);
  369.         l1 = tailmark->m_line->l_next;
  370.         DelMark(tailmark);
  371.         c1 = 0;
  372.     } while (l1 != NULL && l2 != rl2);
  373. }
  374.  
  375. void
  376. do_rfill(ulm)
  377. bool    ulm;
  378. {
  379.     Mark    *mp = CurMark();
  380.     LinePtr    l1 = curline,
  381.         l2 = mp->m_line;
  382.     int    c1 = curchar,
  383.         c2 = mp->m_char;
  384.  
  385.     use_lmargin = ulm;
  386.     (void) fixorder(&l1, &c1, &l2, &c2);
  387.     DoJustify(l1, c1, l2, c2, NO, use_lmargin ? LMargin : 0);
  388. }
  389.  
  390. private void
  391. do_space()
  392. {
  393.     int
  394.         c1,
  395.         diff,
  396.         nspace = 0;
  397.     bool
  398.         funny_space = NO;
  399.  
  400.     skip_wht_space();
  401.     for (c1 = curchar; --c1 >= 0 && jiswhite(linebuf[c1]); )
  402.         if (linebuf[c1] != ' ')
  403.             funny_space = YES;
  404.     c1 += 1;
  405.     diff = (curchar - c1);
  406.  
  407.     if (diff != 0) {
  408.         if (c1 > 0 && !eolp()) {
  409.             nspace = 1;
  410.             if (diff >= 2) {
  411.                 int    topunct = c1;
  412.  
  413.                 do {
  414.                     topunct -= 1;;
  415.                 } while (topunct > 0 && strchr("\"')]", linebuf[topunct]) != NULL);
  416.  
  417.                 if (SpaceSent2 && topunct > 0
  418.                 && (linebuf[c1-1] == ':' || strchr("?!.", linebuf[topunct]) != NULL))
  419.                     nspace = 2;
  420.             }
  421.         }
  422.  
  423.         if (funny_space || diff > nspace) {
  424.             del_char(BACKWARD, diff, NO);
  425.             ins_str("  "+(2-nspace));
  426.         }
  427.     }
  428. }
  429.  
  430. #ifdef MSDOS
  431. /*#pragma loop_opt(off) */
  432. #endif
  433.  
  434. void
  435. DoJustify(l1, c1, l2, c2, scrunch, indent)
  436. LinePtr    l1,
  437.     l2;
  438. int    c1,
  439.     c2,
  440.     indent;
  441. bool
  442.     scrunch;
  443. {
  444.     Mark    *savedot = MakeMark(curline, curchar),
  445.         *endmark;
  446.     int    okay_char,    /* end of what fits */
  447.         start_char;    /* where we started the line */
  448.  
  449.     (void) fixorder(&l1, &c1, &l2, &c2);    /* l1/c1 will be before l2/c2 */
  450.     DotTo(l1, c1);
  451.     if (get_indent(l1) >= c1) {
  452.         if (use_lmargin) {
  453.             Bol();
  454.             n_indent(indent + (head_indent - body_indent));
  455.             use_lmargin = NO;    /* turn this off now */
  456.         }
  457.         ToIndent();
  458.     }
  459.     endmark = MakeMark(l2, c2);
  460.  
  461.     okay_char = start_char = curchar;
  462.     for (;;) {
  463.         /* for each word ... */
  464.  
  465.         /* skip to end of (possibly empty) input word */
  466.         while (!eolp() && !jiswhite(linebuf[curchar]))
  467.             curchar += 1;
  468.  
  469.         if (okay_char != start_char && calc_pos(linebuf, curchar) > RMargin) {
  470.             /* This word won't fit in output line
  471.              * (the first word on a line is always considered to fit).
  472.              */
  473.             curchar = okay_char;    /* go back to last success */
  474.             if (eolp()) {
  475.                 /* no need to introduce a line break: we're already at one */
  476.                 if (lastp(curline))
  477.                     break;    /* ran out of buffer: stop */
  478.                 line_move(FORWARD, 1, NO);
  479.             } else {
  480.                 /* break line here.  Note that we split the line before
  481.                  * deleting the (possibly split) whitespace.  This way
  482.                  * marks before and after the current whitespace character
  483.                  * end up on the appropriate side of the newline that
  484.                  * replaces it.
  485.                  */
  486.                 LineInsert(1);
  487.                 b_char(1);
  488.                 DelWtSpace();
  489.                 f_char(1);
  490.                 DelWtSpace();
  491.                 if (scrunch && TwoBlank()) {
  492.                     Eol();
  493.                     del_char(FORWARD, 1, NO);
  494.                     Bol();
  495.                 }
  496.             }
  497.             n_indent(indent);
  498.             okay_char = start_char = curchar;
  499.         } else {
  500.             /* this word fits (it might be empty, but that's OK) */
  501.             okay_char = curchar;    /* nail down success */
  502.             /* stop if we've run out of range */
  503.             if (curline == endmark->m_line && curchar >= endmark->m_char)
  504.                 break;
  505.             /* process word separator */
  506.             if (eolp() && !lastp(curline)) {
  507.                 /* Replace line separator with TWO spaces: this
  508.                  * allows sentence ends to end up with two spaces.
  509.                  */
  510.                 del_char(FORWARD, 1, NO);
  511.                 ins_str("  ");
  512.             }
  513.             do_space();    /* compress space; advance past it */
  514.         }
  515.     }
  516.     ToMark(savedot);    /* Back to where we were */
  517.     DelMark(endmark);    /* Free up marks */
  518.     DelMark(savedot);
  519.     /* ??? why is the following necessary? -- DHR */
  520.     this_cmd = last_cmd = OTHER_CMD;    /* So everything is under control */
  521.     f_mess(NullStr);
  522. }
  523.  
  524. #ifdef MSDOS
  525. /*#pragma loop_opt() */
  526. #endif
  527.  
  528. private void
  529. DoPara(dir)
  530. int    dir;
  531. {
  532.     register int    num = arg_value();
  533.     bool    first_time = YES;
  534.  
  535.     if (num < 0) {
  536.         num = -num;
  537.         dir = -dir;
  538.     }
  539.     while (--num >= 0) {
  540. tryagain:
  541.         find_para(dir);        /* find paragraph bounderies */
  542.         if (dir == BACKWARD
  543.         && (!first_time || (para_head == curline && bolp())))
  544.         {
  545.             if (bobp())
  546.                 complain((char *)NULL);
  547.             b_char(1);
  548.             first_time = !first_time;
  549.             goto tryagain;
  550.         }
  551.         SetLine((dir == BACKWARD) ? para_head : para_tail);
  552.         if (dir == BACKWARD && !firstp(curline)
  553.         && i_blank(curline->l_prev)) {
  554.             line_move(BACKWARD, 1, NO);
  555.         } else if (dir == FORWARD) {
  556.             if (lastp(curline)) {
  557.                 Eol();
  558.                 break;
  559.             }
  560.             /* otherwise */
  561.             line_move(FORWARD, 1, NO);
  562.         }
  563.     }
  564. }
  565.  
  566. void
  567. BackPara()
  568. {
  569.     DoPara(BACKWARD);
  570. }
  571.  
  572. void
  573. ForPara()
  574. {
  575.     DoPara(FORWARD);
  576. }
  577.