Reduce the amount of code by moving the three copies of the ohash

[mandoc.git] / term.c

diff --git a/term.c b/term.c
index 33f8f90027ac802912ebd69433a9e12b536aefa0..973b404edaa06d4e52048faf9e86c33a9c1ee136 100644 (file)
--- a/term.c
+++ b/term.c
@@ -1,15 +1,15 @@
-/*     $Id: term.c,v 1.237 2014/12/02 10:08:06 schwarze Exp $ */
+/*     $Id: term.c,v 1.253 2015/10/12 00:08:16 schwarze Exp $ */

 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>

- * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010-2015 Ingo Schwarze <schwarze@openbsd.org>

  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *

- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES

  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF


@@ -43,12 +43,13 @@ term_free(struct termp *p)
 {
 
        free(p->buf);
 {
 
        free(p->buf);

+       free(p->fontq);

        free(p);
 }
 
 void
 term_begin(struct termp *p, term_margin head,
        free(p);
 }
 
 void
 term_begin(struct termp *p, term_margin head,

-               term_margin foot, const void *arg)
+               term_margin foot, const struct roff_meta *arg)

 {
 
        p->headf = head;
 {
 
        p->headf = head;


@@ -77,6 +78,8 @@ term_end(struct termp *p)
  *    the next column.  However, if less than p->trailspace blanks,
  *    which can be 0, 1, or 2, remain to the right margin, the line
  *    will be broken.
  *    the next column.  However, if less than p->trailspace blanks,
  *    which can be 0, 1, or 2, remain to the right margin, the line
  *    will be broken.

+ *  - TERMP_BRTRSP: Consider trailing whitespace significant
+ *    when deciding whether the chunk fits or not.

  *  - TERMP_BRIND: If the chunk does not fit and the output line has
  *    to be broken, start the next line at the right margin instead
  *    of at the offset.  Used together with TERMP_NOBREAK for the tags
  *  - TERMP_BRIND: If the chunk does not fit and the output line has
  *    to be broken, start the next line at the right margin instead
  *    of at the offset.  Used together with TERMP_NOBREAK for the tags


@@ -100,7 +103,6 @@ term_flushln(struct termp *p)
        size_t           j;     /* temporary loop index for p->buf */
        size_t           jhy;   /* last hyph before overflow w/r/t j */
        size_t           maxvis; /* output position of visible boundary */
        size_t           j;     /* temporary loop index for p->buf */
        size_t           jhy;   /* last hyph before overflow w/r/t j */
        size_t           maxvis; /* output position of visible boundary */

-       size_t           rmargin; /* the rightmost of the two margins */

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


@@ -113,8 +115,7 @@ term_flushln(struct termp *p)
         * is negative, it gets sign extended.  Subtracting that
         * very large size_t effectively adds a small number to dv.
         */
         * is negative, it gets sign extended.  Subtracting that
         * very large size_t effectively adds a small number to dv.
         */

-       rmargin = p->rmargin > p->offset ? p->rmargin : p->offset;
-       dv = p->rmargin - p->offset;
+       dv = p->rmargin > p->offset ? p->rmargin - p->offset : 0;

        maxvis = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;
 
        if (p->flags & TERMP_NOBREAK) {
        maxvis = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;
 
        if (p->flags & TERMP_NOBREAK) {


@@ -192,8 +193,9 @@ term_flushln(struct termp *p)
                        (*p->endline)(p);
                        p->viscol = 0;
                        if (TERMP_BRIND & p->flags) {
                        (*p->endline)(p);
                        p->viscol = 0;
                        if (TERMP_BRIND & p->flags) {

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

                        } else
                                vbl = p->offset;
 
                        } else
                                vbl = p->offset;
 


@@ -265,6 +267,7 @@ term_flushln(struct termp *p)
 
        p->col = 0;
        p->overstep = 0;
 
        p->col = 0;
        p->overstep = 0;

+       p->flags &= ~(TERMP_BACKAFTER | TERMP_BACKBEFORE);

 
        if ( ! (TERMP_NOBREAK & p->flags)) {
                p->viscol = 0;
 
        if ( ! (TERMP_NOBREAK & p->flags)) {
                p->viscol = 0;


@@ -273,7 +276,7 @@ term_flushln(struct termp *p)
        }
 
        if (TERMP_HANG & p->flags) {
        }
 
        if (TERMP_HANG & p->flags) {

-               p->overstep = (int)(vis - maxvis +
+               p->overstep += (int)(p->offset + vis - p->rmargin +

                    p->trailspace * (*p->width)(p, ' '));
 
                /*
                    p->trailspace * (*p->width)(p, ' '));
 
                /*


@@ -290,6 +293,10 @@ term_flushln(struct termp *p)
        } else if (TERMP_DANGLE & p->flags)
                return;
 
        } else if (TERMP_DANGLE & p->flags)
                return;
 

+       /* Trailing whitespace is significant in some columns. */
+       if (vis && vbl && (TERMP_BRTRSP & p->flags))
+               vis += vbl;
+

        /* If the column was overrun, break the line. */
        if (maxvis < vis + p->trailspace * (*p->width)(p, ' ')) {
                (*p->endline)(p);
        /* If the column was overrun, break the line. */
        if (maxvis < vis + p->trailspace * (*p->width)(p, ' ')) {
                (*p->endline)(p);


@@ -329,6 +336,7 @@ term_vspace(struct termp *p)
                (*p->endline)(p);
 }
 
                (*p->endline)(p);
 }
 

+/* Swap current and previous font; for \fP and .ft P */

 void
 term_fontlast(struct termp *p)
 {
 void
 term_fontlast(struct termp *p)
 {


@@ -339,6 +347,7 @@ term_fontlast(struct termp *p)
        p->fontq[p->fonti] = f;
 }
 
        p->fontq[p->fonti] = f;
 }
 

+/* Set font, save current, discard previous; for \f, .ft, .B etc. */

 void
 term_fontrepl(struct termp *p, enum termfont f)
 {
 void
 term_fontrepl(struct termp *p, enum termfont f)
 {


@@ -347,38 +356,31 @@ term_fontrepl(struct termp *p, enum termfont f)
        p->fontq[p->fonti] = f;
 }
 
        p->fontq[p->fonti] = f;
 }
 

+/* Set font, save previous. */

 void
 term_fontpush(struct termp *p, enum termfont f)
 {
 
 void
 term_fontpush(struct termp *p, enum termfont f)
 {
 

-       assert(p->fonti + 1 < 10);

        p->fontl = p->fontq[p->fonti];
        p->fontl = p->fontq[p->fonti];

-       p->fontq[++p->fonti] = f;
-}
-
-const void *
-term_fontq(struct termp *p)
-{
-
-       return(&p->fontq[p->fonti]);
-}
-
-enum termfont
-term_fonttop(struct termp *p)
-{
-
-       return(p->fontq[p->fonti]);
+       if (++p->fonti == p->fontsz) {
+               p->fontsz += 8;
+               p->fontq = mandoc_reallocarray(p->fontq,
+                   p->fontsz, sizeof(enum termfont *));
+       }
+       p->fontq[p->fonti] = f;

 }
 
 }
 

+/* Flush to make the saved pointer current again. */

 void
 void

-term_fontpopq(struct termp *p, const void *key)
+term_fontpopq(struct termp *p, int i)

 {
 
 {
 

-       while (p->fonti >= 0 && key < (void *)(p->fontq + p->fonti))
-               p->fonti--;
-       assert(p->fonti >= 0);
+       assert(i >= 0);
+       if (p->fonti > i)
+               p->fonti = i;

 }
 
 }
 

+/* Pop one font off the stack. */

 void
 term_fontpop(struct termp *p)
 {
 void
 term_fontpop(struct termp *p)
 {


@@ -418,14 +420,10 @@ term_word(struct termp *p, const char *word)
                p->flags |= TERMP_NOSPACE;
 
        p->flags &= ~(TERMP_SENTENCE | TERMP_NONEWLINE);
                p->flags |= TERMP_NOSPACE;
 
        p->flags &= ~(TERMP_SENTENCE | TERMP_NONEWLINE);

+       p->skipvsp = 0;

 
        while ('\0' != *word) {
                if ('\\' != *word) {
 
        while ('\0' != *word) {
                if ('\\' != *word) {

-                       if (TERMP_SKIPCHAR & p->flags) {
-                               p->flags &= ~TERMP_SKIPCHAR;
-                               word++;
-                               continue;
-                       }

                        if (TERMP_NBRWORD & p->flags) {
                                if (' ' == *word) {
                                        encode(p, nbrsp, 1);
                        if (TERMP_NBRWORD & p->flags) {
                                if (' ' == *word) {
                                        encode(p, nbrsp, 1);


@@ -476,7 +474,6 @@ term_word(struct termp *p, const char *word)
                        term_fontrepl(p, TERMFONT_BI);
                        continue;
                case ESCAPE_FONT:
                        term_fontrepl(p, TERMFONT_BI);
                        continue;
                case ESCAPE_FONT:

-                       /* FALLTHROUGH */

                case ESCAPE_FONTROMAN:
                        term_fontrepl(p, TERMFONT_NONE);
                        continue;
                case ESCAPE_FONTROMAN:
                        term_fontrepl(p, TERMFONT_NONE);
                        continue;


@@ -484,13 +481,32 @@ term_word(struct termp *p, const char *word)
                        term_fontlast(p);
                        continue;
                case ESCAPE_NOSPACE:
                        term_fontlast(p);
                        continue;
                case ESCAPE_NOSPACE:

-                       if (TERMP_SKIPCHAR & p->flags)
-                               p->flags &= ~TERMP_SKIPCHAR;
-                       else if ('\0' == *word)
+                       if (p->flags & TERMP_BACKAFTER)
+                               p->flags &= ~TERMP_BACKAFTER;
+                       else if (*word == '\0')

                                p->flags |= (TERMP_NOSPACE | TERMP_NONEWLINE);
                        continue;
                case ESCAPE_SKIPCHAR:
                                p->flags |= (TERMP_NOSPACE | TERMP_NONEWLINE);
                        continue;
                case ESCAPE_SKIPCHAR:

-                       p->flags |= TERMP_SKIPCHAR;
+                       p->flags |= TERMP_BACKAFTER;
+                       continue;
+               case ESCAPE_OVERSTRIKE:
+                       cp = seq + sz;
+                       while (seq < cp) {
+                               if (*seq == '\\') {
+                                       mandoc_escape(&seq, NULL, NULL);
+                                       continue;
+                               }
+                               encode1(p, *seq++);
+                               if (seq < cp) {
+                                       if (p->flags & TERMP_BACKBEFORE)
+                                               p->flags |= TERMP_BACKAFTER;
+                                       else
+                                               p->flags |= TERMP_BACKBEFORE;
+                               }
+                       }
+                       /* Trim trailing backspace/blank pair. */
+                       if (p->col > 2 && p->buf[p->col - 1] == ' ')
+                               p->col -= 2;

                        continue;
                default:
                        continue;
                        continue;
                default:
                        continue;


@@ -546,16 +562,19 @@ encode1(struct termp *p, int c)
 {
        enum termfont     f;
 
 {
        enum termfont     f;
 

-       if (TERMP_SKIPCHAR & p->flags) {
-               p->flags &= ~TERMP_SKIPCHAR;
-               return;
-       }
-
-       if (p->col + 6 >= p->maxcols)
-               adjbuf(p, p->col + 6);
+       if (p->col + 7 >= p->maxcols)
+               adjbuf(p, p->col + 7);

 
 

-       f = term_fonttop(p);
+       f = (c == ASCII_HYPH || isgraph(c)) ?
+           p->fontq[p->fonti] : TERMFONT_NONE;

 
 

+       if (p->flags & TERMP_BACKBEFORE) {
+               if (p->buf[p->col - 1] == ' ')
+                       p->col--;
+               else
+                       p->buf[p->col++] = 8;
+               p->flags &= ~TERMP_BACKBEFORE;
+       }

        if (TERMFONT_UNDER == f || TERMFONT_BI == f) {
                p->buf[p->col++] = '_';
                p->buf[p->col++] = 8;
        if (TERMFONT_UNDER == f || TERMFONT_BI == f) {
                p->buf[p->col++] = '_';
                p->buf[p->col++] = 8;


@@ -568,6 +587,10 @@ encode1(struct termp *p, int c)
                p->buf[p->col++] = 8;
        }
        p->buf[p->col++] = c;
                p->buf[p->col++] = 8;
        }
        p->buf[p->col++] = c;

+       if (p->flags & TERMP_BACKAFTER) {
+               p->flags |= TERMP_BACKBEFORE;
+               p->flags &= ~TERMP_BACKAFTER;
+       }

 }
 
 static void
 }
 
 static void


@@ -575,29 +598,8 @@ encode(struct termp *p, const char *word, size_t sz)
 {
        size_t            i;
 
 {
        size_t            i;
 

-       if (TERMP_SKIPCHAR & p->flags) {
-               p->flags &= ~TERMP_SKIPCHAR;
-               return;
-       }
-
-       /*
-        * Encode and buffer a string of characters.  If the current
-        * font mode is unset, buffer directly, else encode then buffer
-        * character by character.
-        */
-
-       if (TERMFONT_NONE == term_fonttop(p)) {
-               if (p->col + sz >= p->maxcols)
-                       adjbuf(p, p->col + sz);
-               for (i = 0; i < sz; i++)
-                       p->buf[p->col++] = word[i];
-               return;
-       }
-
-       /* Pre-buffer, assuming worst-case. */
-
-       if (p->col + 1 + (sz * 5) >= p->maxcols)
-               adjbuf(p, p->col + 1 + (sz * 5));
+       if (p->col + 2 + (sz * 5) >= p->maxcols)
+               adjbuf(p, p->col + 2 + (sz * 5));

 
        for (i = 0; i < sz; i++) {
                if (ASCII_HYPH == word[i] ||
 
        for (i = 0; i < sz; i++) {
                if (ASCII_HYPH == word[i] ||


@@ -612,8 +614,7 @@ void
 term_setwidth(struct termp *p, const char *wstr)
 {
        struct roffsu    su;
 term_setwidth(struct termp *p, const char *wstr)
 {
        struct roffsu    su;

-       size_t           width;
-       int              iop;
+       int              iop, width;

 
        iop = 0;
        width = 0;
 
        iop = 0;
        width = 0;


@@ -642,7 +643,7 @@ size_t
 term_len(const struct termp *p, size_t sz)
 {
 
 term_len(const struct termp *p, size_t sz)
 {
 

-       return((*p->width)(p, ' ') * sz);
+       return (*p->width)(p, ' ') * sz;

 }
 
 static size_t
 }
 
 static size_t


@@ -651,9 +652,9 @@ cond_width(const struct termp *p, int c, int *skip)
 
        if (*skip) {
                (*skip) = 0;
 
        if (*skip) {
                (*skip) = 0;

-               return(0);
+               return 0;

        } else
        } else

-               return((*p->width)(p, c));
+               return (*p->width)(p, c);

 }
 
 size_t
 }
 
 size_t


@@ -713,6 +714,20 @@ term_strlen(const struct termp *p, const char *cp)
                        case ESCAPE_SKIPCHAR:
                                skip = 1;
                                continue;
                        case ESCAPE_SKIPCHAR:
                                skip = 1;
                                continue;

+                       case ESCAPE_OVERSTRIKE:
+                               rsz = 0;
+                               rhs = seq + ssz;
+                               while (seq < rhs) {
+                                       if (*seq == '\\') {
+                                               mandoc_escape(&seq, NULL, NULL);
+                                               continue;
+                                       }
+                                       i = (*p->width)(p, *seq++);
+                                       if (rsz < i)
+                                               rsz = i;
+                               }
+                               sz += rsz;
+                               continue;

                        default:
                                continue;
                        }
                        default:
                                continue;
                        }


@@ -755,58 +770,63 @@ term_strlen(const struct termp *p, const char *cp)
                case ASCII_HYPH:
                        sz += cond_width(p, '-', &skip);
                        cp++;
                case ASCII_HYPH:
                        sz += cond_width(p, '-', &skip);
                        cp++;

-                       /* FALLTHROUGH */
-               case ASCII_BREAK:

                        break;
                default:
                        break;
                }
        }
 
                        break;
                default:
                        break;
                }
        }
 

-       return(sz);
+       return sz;

 }
 
 }
 

-size_t
+int

 term_vspan(const struct termp *p, const struct roffsu *su)
 {
        double           r;
 term_vspan(const struct termp *p, const struct roffsu *su)
 {
        double           r;

+       int              ri;

 
        switch (su->unit) {
 
        switch (su->unit) {

+       case SCALE_BU:
+               r = su->scale / 40.0;
+               break;

        case SCALE_CM:
        case SCALE_CM:

-               r = su->scale * 2.0;
+               r = su->scale * 6.0 / 2.54;
+               break;
+       case SCALE_FS:
+               r = su->scale * 65536.0 / 40.0;

                break;
        case SCALE_IN:
                r = su->scale * 6.0;
                break;
                break;
        case SCALE_IN:
                r = su->scale * 6.0;
                break;

+       case SCALE_MM:
+               r = su->scale * 0.006;
+               break;

        case SCALE_PC:
                r = su->scale;
                break;
        case SCALE_PT:
        case SCALE_PC:
                r = su->scale;
                break;
        case SCALE_PT:

-               r = su->scale / 8.0;
+               r = su->scale / 12.0;

                break;
                break;

-       case SCALE_MM:
-               r = su->scale / 1000.0;
+       case SCALE_EN:
+       case SCALE_EM:
+               r = su->scale * 0.6;

                break;
        case SCALE_VS:
                r = su->scale;
                break;
        default:
                break;
        case SCALE_VS:
                r = su->scale;
                break;
        default:

-               r = su->scale - 1.0;
-               break;
+               abort();

        }
        }

-
-       if (r < 0.0)
-               r = 0.0;
-       return((size_t)(r + 0.0005));
+       ri = r > 0.0 ? r + 0.4995 : r - 0.4995;
+       return ri < 66 ? ri : 1;

 }
 
 }
 

-size_t
+/*
+ * Convert a scaling width to basic units, rounding down.
+ */
+int

 term_hspan(const struct termp *p, const struct roffsu *su)
 {
 term_hspan(const struct termp *p, const struct roffsu *su)
 {

-       double           v;

 
 

-       v = (*p->hspan)(p, su);
-       if (v < 0.0)
-               v = 0.0;
-       return((size_t)(v + 0.0005));
+       return (*p->hspan)(p, su);

 }
 }