Support for TERMP_HANG in flushln(): -hang lists.

[mandoc.git] / term.c

diff --git a/term.c b/term.c
index 2d1a66078972b1d3ede5ae4964d1d1012d95d4de..973ad2c2b1c7d3f66081b614fac9048d6e5e41bc 100644 (file)
--- a/term.c
+++ b/term.c
@@ -1,6 +1,6 @@
-/*     $Id: term.c,v 1.74 2009/04/12 19:45:26 kristaps Exp $ */
+/*     $Id: term.c,v 1.84 2009/07/14 15:16:41 kristaps Exp $ */

 /*
 /*

- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
+ * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>

  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above


@@ -37,8 +37,7 @@ static        void              term_pescape(struct termp *,
 static void              term_nescape(struct termp *,
                                const char *, size_t);
 static void              term_chara(struct termp *, char);
 static void              term_nescape(struct termp *,
                                const char *, size_t);
 static void              term_chara(struct termp *, char);

-static void              term_stringa(struct termp *, 
-                               const char *, size_t);
+static void              term_encodea(struct termp *, char);

 static int               term_isopendelim(const char *, int);
 static int               term_isclosedelim(const char *, int);
 
 static int               term_isopendelim(const char *, int);
 static int               term_isclosedelim(const char *, int);
 


@@ -177,8 +176,7 @@ term_isopendelim(const char *p, int len)
  * Specifically, a line is whatever's in p->buf of length p->col, which
  * is zeroed after this function returns.
  *
  * Specifically, a line is whatever's in p->buf of length p->col, which
  * is zeroed after this function returns.
  *

- * The variables TERMP_NOLPAD, TERMP_LITERAL and TERMP_NOBREAK are of
- * critical importance here.  Their behaviour follows:
+ * The usage of termp:flags is as follows:

  *
  *  - TERMP_NOLPAD: when beginning to write the line, don't left-pad the
  *    offset value.  This is useful when doing columnar lists where the
  *
  *  - TERMP_NOLPAD: when beginning to write the line, don't left-pad the
  *    offset value.  This is useful when doing columnar lists where the


@@ -188,7 +186,12 @@ term_isopendelim(const char *p, int len)
  *    columns.  In short: don't print a newline and instead pad to the
  *    right margin.  Used in conjunction with TERMP_NOLPAD.
  *
  *    columns.  In short: don't print a newline and instead pad to the
  *    right margin.  Used in conjunction with TERMP_NOLPAD.
  *

- *  - TERMP_NONOBREAK: don't newline when TERMP_NOBREAK is specified.
+ *  - TERMP_DANGLE: don't newline when TERMP_NOBREAK is specified and
+ *    the line is overrun, and don't pad-right if it's underrun.
+ *
+ *  - TERMP_HANG: like TERMP_DANGLE, but doesn't newline when
+ *    overruning, instead save the position and continue at that point
+ *    when the next invocation.

  *
  *  In-line line breaking:
  *
  *
  *  In-line line breaking:
  *


@@ -201,12 +204,16 @@ term_isopendelim(const char *p, int len)
  *  Otherwise, the line will break at the right margin.  Extremely long
  *  lines will cause the system to emit a warning (TODO: hyphenate, if
  *  possible).
  *  Otherwise, the line will break at the right margin.  Extremely long
  *  lines will cause the system to emit a warning (TODO: hyphenate, if
  *  possible).

+ *
+ *  FIXME: newline breaks occur (in groff) also occur when a single
+ *  space follows a NOBREAK!

  */
 void
 term_flushln(struct termp *p)
 {
        int              i, j;
  */
 void
 term_flushln(struct termp *p)
 {
        int              i, j;

-       size_t           vsz, vis, maxvis, mmax, bp;
+       size_t           vbl, vsz, vis, maxvis, mmax, bp;
+       static int       sv = -1;

 
        /*
         * First, establish the maximum columns of "visible" content.
 
        /*
         * First, establish the maximum columns of "visible" content.


@@ -221,6 +228,11 @@ term_flushln(struct termp *p)
        bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
        vis = 0;
 
        bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
        vis = 0;
 

+       if (sv >= 0) {
+               vis = (size_t)sv;
+               sv = -1;
+       }
+

        /*
         * If in the standard case (left-justified), then begin with our
         * indentation, otherwise (columns, etc.) just start spitting
        /*
         * If in the standard case (left-justified), then begin with our
         * indentation, otherwise (columns, etc.) just start spitting


@@ -251,43 +263,43 @@ term_flushln(struct termp *p)
                }
 
                /*
                }
 
                /*

-                * Do line-breaking.  If we're greater than our
-                * break-point and already in-line, break to the next
-                * line and start writing.  If we're at the line start,
-                * then write out the word (TODO: hyphenate) and break
-                * in a subsequent loop invocation.
+                * Choose the number of blanks to prepend: no blank at the
+                * beginning of a line, one between words -- but do not
+                * actually write them yet.

                 */
                 */

+               vbl = (size_t)(0 == vis ? 0 : 1);

 
 

-               if ( ! (TERMP_NOBREAK & p->flags)) {
-                       if (vis && vis + vsz > bp) {
-                               putchar('\n');
+               /*
+                * Find out whether we would exceed the right margin.
+                * If so, break to the next line.  (TODO: hyphenate)
+                * Otherwise, write the chosen number of blanks now.
+                */
+               if (vis && vis + vbl + vsz > bp) {
+                       putchar('\n');
+                       if (TERMP_NOBREAK & p->flags) {
+                               for (j = 0; j < (int)p->rmargin; j++)
+                                       putchar(' ');
+                               vis = p->rmargin - p->offset;
+                       } else {

                                for (j = 0; j < (int)p->offset; j++)
                                        putchar(' ');
                                vis = 0;
                                for (j = 0; j < (int)p->offset; j++)
                                        putchar(' ');
                                vis = 0;

-                       } 
-               } else if (vis && vis + vsz > bp) {
-                       putchar('\n');
-                       for (j = 0; j < (int)p->rmargin; j++)
+                       }
+               } else {
+                       for (j = 0; j < (int)vbl; j++)

                                putchar(' ');
                                putchar(' ');

-                       vis = p->rmargin - p->offset;
+                       vis += vbl;

                }
 
                }
 

-               /* 
-                * Write out the word and a trailing space.  Omit the
-                * space if we're the last word in the line or beyond
-                * our breakpoint.
+               /*
+                * Finally, write out the word.

                 */
                 */

-

                for ( ; i < (int)p->col; i++) {
                        if (' ' == p->buf[i])
                                break;
                        putchar(p->buf[i]);
                }
                vis += vsz;
                for ( ; i < (int)p->col; i++) {
                        if (' ' == p->buf[i])
                                break;
                        putchar(p->buf[i]);
                }
                vis += vsz;

-               if (i < (int)p->col && vis <= bp) {
-                       putchar(' ');
-                       vis++;
-               }

        }
 
        /*
        }
 
        /*


@@ -296,11 +308,14 @@ term_flushln(struct termp *p)
         */
 
        if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {
         */
 
        if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {

-               if ( ! (TERMP_NONOBREAK & p->flags)) {
+               if ( ! (TERMP_DANGLE & p->flags) &&
+                               ! (TERMP_HANG & p->flags)) {

                        putchar('\n');
                        for (i = 0; i < (int)p->rmargin; i++)
                                putchar(' ');
                }
                        putchar('\n');
                        for (i = 0; i < (int)p->rmargin; i++)
                                putchar(' ');
                }

+               if (TERMP_HANG & p->flags)
+                       sv = vis - maxvis;

                p->col = 0;
                return;
        }
                p->col = 0;
                return;
        }


@@ -311,7 +326,7 @@ term_flushln(struct termp *p)
         */
 
        if (p->flags & TERMP_NOBREAK) {
         */
 
        if (p->flags & TERMP_NOBREAK) {

-               if ( ! (TERMP_NONOBREAK & p->flags))
+               if ( ! (TERMP_DANGLE & p->flags))

                        for ( ; vis < maxvis; vis++)
                                putchar(' ');
        } else
                        for ( ; vis < maxvis; vis++)
                                putchar(' ');
        } else


@@ -409,10 +424,12 @@ term_nescape(struct termp *p, const char *word, size_t len)
 {
        const char      *rhs;
        size_t           sz;
 {
        const char      *rhs;
        size_t           sz;

+       int              i;

 
 

-       if (NULL == (rhs = term_a2ascii(p->symtab, word, len, &sz))) 
-               return;
-       term_stringa(p, rhs, sz);
+       rhs = term_a2ascii(p->symtab, word, len, &sz);
+       if (rhs)
+               for (i = 0; i < (int)sz; i++) 
+                       term_encodea(p, rhs[i]);

 }
 
 
 }
 
 


@@ -521,60 +538,17 @@ term_pword(struct termp *p, const char *word, int len)
         * before the word.
         */
 
         * before the word.
         */
 

-       for (i = 0; i < len; i++) {
-               if ('\\' == word[i]) {
+       for (i = 0; i < len; i++) 
+               if ('\\' == word[i]) 

                        term_pescape(p, word, &i, len);
                        term_pescape(p, word, &i, len);

-                       continue;
-               }
-
-               if (TERMP_STYLE & p->flags) {
-                       if (TERMP_BOLD & p->flags) {
-                               term_chara(p, word[i]);
-                               term_chara(p, 8);
-                       }
-                       if (TERMP_UNDER & p->flags) {
-                               term_chara(p, '_');
-                               term_chara(p, 8);
-                       }
-               }
-
-               term_chara(p, word[i]);
-       }
+               else
+                       term_encodea(p, word[i]);

 
        if (term_isopendelim(word, len))
                p->flags |= TERMP_NOSPACE;
 }
 
 
 
        if (term_isopendelim(word, len))
                p->flags |= TERMP_NOSPACE;
 }
 
 

-/*
- * Like term_chara() but for arbitrary-length buffers.  Resize the
- * buffer by a factor of two (if the buffer is less than that) or the
- * buffer's size.
- */
-static void
-term_stringa(struct termp *p, const char *c, size_t sz)
-{
-       size_t           s;
-
-       if (0 == sz)
-               return;
-
-       assert(c);
-       if (p->col + sz >= p->maxcols) {
-               if (0 == p->maxcols)
-                       p->maxcols = 256;
-               s = sz > p->maxcols * 2 ? sz : p->maxcols * 2;
-               p->buf = realloc(p->buf, s);
-               if (NULL == p->buf)
-                       err(1, "realloc");
-               p->maxcols = s;
-       }
-
-       (void)memcpy(&p->buf[(int)p->col], c, sz);
-       p->col += sz;
-}
-
-

 /*
  * Insert a single character into the line-buffer.  If the buffer's
  * space is exceeded, then allocate more space by doubling the buffer
 /*
  * Insert a single character into the line-buffer.  If the buffer's
  * space is exceeded, then allocate more space by doubling the buffer


@@ -597,3 +571,20 @@ term_chara(struct termp *p, char c)
        p->buf[(int)(p->col)++] = c;
 }
 
        p->buf[(int)(p->col)++] = c;
 }
 

+
+static void
+term_encodea(struct termp *p, char c)
+{
+
+       if (TERMP_STYLE & p->flags) {
+               if (TERMP_BOLD & p->flags) {
+                       term_chara(p, c);
+                       term_chara(p, 8);
+               }
+               if (TERMP_UNDER & p->flags) {
+                       term_chara(p, '_');
+                       term_chara(p, 8);
+               }
+       }
+       term_chara(p, c);
+}