Fix to auto-closing of LINK tag in -Txhtml (thanks to Daniel Friesel).

[mandoc.git] / term.c

diff --git a/term.c b/term.c
index ae0742cd56aa267d11d528716c83a3f98dfa8c6d..eb4c1217dbedd2d7cafe7fffe3db8bfdbe4a56f5 100644 (file)
--- a/term.c
+++ b/term.c
@@ -1,4 +1,4 @@
-/*     $Id: term.c,v 1.125 2009/11/12 05:50:12 kristaps Exp $ */
+/*     $Id: term.c,v 1.131 2010/04/08 07:05:38 kristaps Exp $ */

 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *


@@ -14,6 +14,12 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <sys/types.h>
+

 #include <assert.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <assert.h>
 #include <ctype.h>
 #include <stdio.h>


@@ -77,7 +83,6 @@ term_alloc(enum termenc enc)
                perror(NULL);
                exit(EXIT_FAILURE);
        }
                perror(NULL);
                exit(EXIT_FAILURE);
        }

-       p->maxrmargin = 78;

        p->enc = enc;
        return(p);
 }
        p->enc = enc;
        return(p);
 }


@@ -87,12 +92,10 @@ term_alloc(enum termenc enc)
  * Flush a line of text.  A "line" is loosely defined as being something
  * that should be followed by a newline, regardless of whether it's
  * broken apart by newlines getting there.  A line can also be a
  * Flush a line of text.  A "line" is loosely defined as being something
  * that should be followed by a newline, regardless of whether it's
  * broken apart by newlines getting there.  A line can also be a

- * fragment of a columnar list.
- *
- * Specifically, a line is whatever's in p->buf of length p->col, which
- * is zeroed after this function returns.
+ * fragment of a columnar list (`Bl -tag' or `Bl -column'), which does
+ * not have a trailing newline.

  *
  *

- * The usage of termp:flags is as follows:
+ * The following flags may be specified:

  *
  *  - 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


@@ -128,9 +131,9 @@ term_flushln(struct termp *p)
        size_t           vbl;   /* number of blanks to prepend to output */
        size_t           vsz;   /* visual characters to write to output */
        size_t           bp;    /* visual right border position */
        size_t           vbl;   /* number of blanks to prepend to output */
        size_t           vsz;   /* visual characters to write to output */
        size_t           bp;    /* visual right border position */

+       size_t           hyph;  /* visible position of hyphen */

        int              j;     /* temporary loop index */
        size_t           maxvis, mmax;
        int              j;     /* temporary loop index */
        size_t           maxvis, mmax;

-       static int       overstep = 0;

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


@@ -141,12 +144,12 @@ term_flushln(struct termp *p)
 
        assert(p->offset < p->rmargin);
 
 
        assert(p->offset < p->rmargin);
 

-       maxvis = (int)(p->rmargin - p->offset) - overstep < 0 ?
+       maxvis = (int)(p->rmargin - p->offset) - p->overstep < 0 ?

                /* LINTED */ 
                /* LINTED */ 

-               0 : p->rmargin - p->offset - overstep;
-       mmax = (int)(p->maxrmargin - p->offset) - overstep < 0 ?
+               0 : p->rmargin - p->offset - p->overstep;
+       mmax = (int)(p->maxrmargin - p->offset) - p->overstep < 0 ?

                /* LINTED */
                /* LINTED */

-               0 : p->maxrmargin - p->offset - overstep;
+               0 : p->maxrmargin - p->offset - p->overstep;

 
        bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
 
 
        bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
 


@@ -174,16 +177,23 @@ term_flushln(struct termp *p)
                 * (starting with the CSI) aren't counted.  A space
                 * generates a non-printing word, which is valid (the
                 * space is printed according to regular spacing rules).
                 * (starting with the CSI) aren't counted.  A space
                 * generates a non-printing word, which is valid (the
                 * space is printed according to regular spacing rules).

+                * Collect the number of printable characters until the
+                * first hyphen, if found.  Hyphens aren't included if
+                * they're the first character (so `Fl' doesn't break)
+                * or second consecutive character (`Fl -').

                 */
 
                /* LINTED */
                 */
 
                /* LINTED */

-               for (j = i, vsz = 0; j < (int)p->col; j++) {
+               for (j = i, vsz = 0, hyph = 0; j < (int)p->col; j++) {

                        if (j && ' ' == p->buf[j]) 
                                break;
                        if (j && ' ' == p->buf[j]) 
                                break;

-                       else if (8 == p->buf[j])
+                       if (8 == p->buf[j])

                                vsz--;
                        else
                                vsz++;
                                vsz--;
                        else
                                vsz++;

+                       if (j > i && '-' == p->buf[j] && 0 == hyph)
+                              if ('-' != p->buf[j - 1])
+                                       hyph = vsz;

                }
 
                /*
                }
 
                /*


@@ -191,14 +201,43 @@ term_flushln(struct termp *p)
                 * beginning of a line, one between words -- but do not
                 * actually write them yet.
                 */
                 * beginning of a line, one between words -- but do not
                 * actually write them yet.
                 */

+

                vbl = (size_t)(0 == vis ? 0 : 1);
 
                /*
                 * Find out whether we would exceed the right margin.
                vbl = (size_t)(0 == vis ? 0 : 1);
 
                /*
                 * 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 so, break to the next line, possibly after
+                * emittign character up to a hyphen.  Otherwise, write
+                * the chosen number of blanks.

                 */
                 */

+

                if (vis && vis + vbl + vsz > bp) {
                if (vis && vis + vbl + vsz > bp) {

+                       /*
+                        * Has a hyphen been found before the breakpoint
+                        * that we can use?
+                        */
+                       if (hyph && vis + vbl + hyph <= bp) {
+                               /* First prepend blanks. */
+                               for (j = 0; j < (int)vbl; j++)
+                                       putchar(' ');
+                               
+                               /* Emit up to the character. */
+                               do {
+                                       if (31 == p->buf[i])
+                                               putchar(' ');
+                                       else
+                                               putchar(p->buf[i]);
+                                       if (8 != p->buf[i])
+                                               vsz--;
+                               } while ('-' != p->buf[i++]);
+
+                               /* Emit trailing decoration. */
+                               if (8 == p->buf[i]) {
+                                       putchar(p->buf[i]);
+                                       putchar(p->buf[i + 1]);
+                               }
+                       } 
+

                        putchar('\n');
                        if (TERMP_NOBREAK & p->flags) {
                                for (j = 0; j < (int)p->rmargin; j++)
                        putchar('\n');
                        if (TERMP_NOBREAK & p->flags) {
                                for (j = 0; j < (int)p->rmargin; j++)


@@ -209,34 +248,32 @@ term_flushln(struct termp *p)
                                        putchar(' ');
                                vis = 0;
                        }
                                        putchar(' ');
                                vis = 0;
                        }

-                       /* Remove the overstep width. */
+
+                       /* Remove the p->overstep width. */
+

                        bp += (int)/* LINTED */
                        bp += (int)/* LINTED */

-                               overstep;
-                       overstep = 0;
+                               p->overstep;
+                       p->overstep = 0;

                } else {
                        for (j = 0; j < (int)vbl; j++)
                                putchar(' ');
                        vis += vbl;
                }
 
                } else {
                        for (j = 0; j < (int)vbl; j++)
                                putchar(' ');
                        vis += vbl;
                }
 

-               /*
-                * Finally, write out the word.
-                */
-               for ( ; i < (int)p->col; i++) {
+               /* Write out the [remaining] word. */
+               for ( ; i < (int)p->col; i++)

                        if (' ' == p->buf[i])
                                break;
                        if (' ' == p->buf[i])
                                break;

-
-                       /* The unit sep. is a non-breaking space. */
-                       if (31 == p->buf[i])
+                       else if (31 == p->buf[i])

                                putchar(' ');
                        else
                                putchar(p->buf[i]);
                                putchar(' ');
                        else
                                putchar(p->buf[i]);

-               }
+

                vis += vsz;
        }
 
        p->col = 0;
                vis += vsz;
        }
 
        p->col = 0;

-       overstep = 0;
+       p->overstep = 0;

 
        if ( ! (TERMP_NOBREAK & p->flags)) {
                putchar('\n');
 
        if ( ! (TERMP_NOBREAK & p->flags)) {
                putchar('\n');


@@ -245,7 +282,7 @@ term_flushln(struct termp *p)
 
        if (TERMP_HANG & p->flags) {
                /* We need one blank after the tag. */
 
        if (TERMP_HANG & p->flags) {
                /* We need one blank after the tag. */

-               overstep = /* LINTED */
+               p->overstep = /* LINTED */

                        vis - maxvis + 1;
 
                /*
                        vis - maxvis + 1;
 
                /*


@@ -258,12 +295,12 @@ term_flushln(struct termp *p)
                 * move it one step LEFT and flag the rest of the line
                 * to be longer.
                 */
                 * move it one step LEFT and flag the rest of the line
                 * to be longer.
                 */

-               if (overstep >= -1) {
-                       assert((int)maxvis + overstep >= 0);
+               if (p->overstep >= -1) {
+                       assert((int)maxvis + p->overstep >= 0);

                        /* LINTED */
                        /* LINTED */

-                       maxvis += overstep;
+                       maxvis += p->overstep;

                } else
                } else

-                       overstep = 0;
+                       p->overstep = 0;

 
        } else if (TERMP_DANGLE & p->flags)
                return;
 
        } else if (TERMP_DANGLE & p->flags)
                return;


@@ -436,8 +473,6 @@ term_word(struct termp *p, const char *word)
                case(')'):
                        /* FALLTHROUGH */
                case(']'):
                case(')'):
                        /* FALLTHROUGH */
                case(']'):

-                       /* FALLTHROUGH */
-               case('}'):

                        if ( ! (TERMP_IGNDELIM & p->flags))
                                p->flags |= TERMP_NOSPACE;
                        break;
                        if ( ! (TERMP_IGNDELIM & p->flags))
                                p->flags |= TERMP_NOSPACE;
                        break;


@@ -485,16 +520,21 @@ term_word(struct termp *p, const char *word)
                default:
                        break;
                }
                default:
                        break;
                }

+

                word += sz;
                word += sz;

+               if (DECO_NOSPACE == deco && '\0' == *word)
+                       p->flags |= TERMP_NOSPACE;

        }
 
        }
 

+       /* 
+        * Note that we don't process the pipe: the parser sees it as
+        * punctuation, but we don't in terms of typography.
+        */

        if (sv[0] && 0 == sv[1])
                switch (sv[0]) {
                case('('):
                        /* FALLTHROUGH */
                case('['):
        if (sv[0] && 0 == sv[1])
                switch (sv[0]) {
                case('('):
                        /* FALLTHROUGH */
                case('['):

-                       /* FALLTHROUGH */
-               case('{'):

                        p->flags |= TERMP_NOSPACE;
                        break;
                default:
                        p->flags |= TERMP_NOSPACE;
                        break;
                default:


@@ -527,7 +567,7 @@ buffera(struct termp *p, const char *word, size_t sz)
        if (p->col + sz >= p->maxcols) 
                adjbuf(p, p->col + sz);
 
        if (p->col + sz >= p->maxcols) 
                adjbuf(p, p->col + sz);
 

-       memcpy(&p->buf[p->col], word, sz);
+       memcpy(&p->buf[(int)p->col], word, sz);

        p->col += sz;
 }
 
        p->col += sz;
 }
 


@@ -539,7 +579,7 @@ bufferc(struct termp *p, char c)
        if (p->col + 1 >= p->maxcols)
                adjbuf(p, p->col + 1);
 
        if (p->col + 1 >= p->maxcols)
                adjbuf(p, p->col + 1);
 

-       p->buf[p->col++] = c;
+       p->buf[(int)p->col++] = c;

 }
 
 
 }