Removed isspace assertion (is handled by pad).

[mandoc.git] / mdocterm.c

diff --git a/mdocterm.c b/mdocterm.c
index 398794ca8fe78df78f42abc0cfabc1836872e8cc..499c4da18d21b86ddf13050beed7a02b23ac2c89 100644 (file)
--- a/mdocterm.c
+++ b/mdocterm.c
@@ -1,4 +1,4 @@
-/* $Id: mdocterm.c,v 1.19 2009/02/28 14:43:35 kristaps Exp $ */
+/* $Id: mdocterm.c,v 1.23 2009/03/01 23:23:55 kristaps Exp $ */

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


@@ -173,9 +173,10 @@ flushln(struct termp *p)
        for (i = 0; i < p->col; i++) {
                /*
                 * Count up visible word characters.  Control sequences
        for (i = 0; i < p->col; i++) {
                /*
                 * Count up visible word characters.  Control sequences

-                * (starting with the CSI) aren't counted. 
+                * (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).

                 */
                 */

-               assert( ! xisspace(p->buf[i]));

 
                /* LINTED */
                for (j = i, vsz = 0; j < p->col; j++) {
 
                /* LINTED */
                for (j = i, vsz = 0; j < p->col; j++) {


@@ -187,26 +188,29 @@ flushln(struct termp *p)
                        } else
                                vsz++;
                }
                        } else
                                vsz++;
                }

-               assert(vsz > 0);

 
                /*
 
                /*

+                * If we're breaking normally...
+                *

                 * If a word is too long and we're within a line, put it
                 * on the next line.  Puke if we're being asked to write
                 * something that will exceed the right margin (i.e.,
                 * If a word is too long and we're within a line, put it
                 * on the next line.  Puke if we're being asked to write
                 * something that will exceed the right margin (i.e.,

-                * from a fresh line or when we're not allowed to break
-                * the line with TERMP_NOBREAK).
+                * from a fresh line).
+                *
+                * If we're not breaking...
+                *
+                * Don't let the visible size exceed the full margin.

                 */
 
                 */
 

-               /* FIXME: allow selective right-margin breaking. */
-
-               if (vis && vis + vsz > maxvis) {
-                       if (p->flags & TERMP_NOBREAK)
+               if ( ! (TERMP_NOBREAK & p->flags)) {
+                       if (vis && vis + vsz > maxvis) {
+                               putchar('\n');
+                               for (j = 0; j < p->offset; j++)
+                                       putchar(' ');
+                               vis = 0;
+                       } else if (vis + vsz > maxvis)

                                errx(1, "word breaks right margin");
                                errx(1, "word breaks right margin");

-                       putchar('\n');
-                       for (j = 0; j < p->offset; j++)
-                               putchar(' ');
-                       vis = 0;
-               } else if (vis + vsz > maxvis)
+               } else if (vis + vsz > p->maxrmargin)

                        errx(1, "word breaks right margin");
 
                /* 
                        errx(1, "word breaks right margin");
 
                /* 


@@ -226,15 +230,22 @@ flushln(struct termp *p)
                }
        }
 
                }
        }
 

+       if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {
+               putchar('\n');
+               for (i = 0; i < p->rmargin; i++)
+                       putchar(' ');
+               p->col = 0;
+               return;
+       }
+

        /*
         * If we're not to right-marginalise it (newline), then instead
         * pad to the right margin and stay off.
         */
 
        if (p->flags & TERMP_NOBREAK) {
        /*
         * If we're not to right-marginalise it (newline), then instead
         * pad to the right margin and stay off.
         */
 
        if (p->flags & TERMP_NOBREAK) {

-               if ( ! (p->flags & TERMP_NORPAD))
-                       for ( ; vis < maxvis; vis++)
-                               putchar(' ');
+               for ( ; vis < maxvis; vis++)
+                       putchar(' ');

        } else
                putchar('\n');
 
        } else
                putchar('\n');
 


@@ -465,6 +476,10 @@ pescape(struct termp *p, const char *word, size_t *i, size_t len)
                        /* FALLTHROUGH */
                case ('.'):
                        chara(p, word[*i]);
                        /* FALLTHROUGH */
                case ('.'):
                        chara(p, word[*i]);

+                       break;
+               case ('e'):
+                       chara(p, '\\');
+                       break;

                default:
                        break;
                }
                default:
                        break;
                }


@@ -484,8 +499,6 @@ pword(struct termp *p, const char *word, size_t len)
 {
        size_t           i;
 
 {
        size_t           i;
 

-       /*assert(len > 0);*/ /* Can be, if literal. */
-

        /*
         * Handle pwords, partial words, which may be either a single
         * word or a phrase that cannot be broken down (such as a
        /*
         * Handle pwords, partial words, which may be either a single
         * word or a phrase that cannot be broken down (such as a


@@ -554,7 +567,14 @@ word(struct termp *p, const char *word)
                if ( ! xisspace(word[i])) {
                        j++;
                        continue;
                if ( ! xisspace(word[i])) {
                        j++;
                        continue;

+               } 
+               
+               /* Escaped spaces don't delimit... */
+               if (i > 0 && xisspace(word[i]) && '\\' == word[i - 1]) {
+                       j++;
+                       continue;

                }
                }

+

                if (0 == j)
                        continue;
                assert(i >= j);
                if (0 == j)
                        continue;
                assert(i >= j);