implement -h (synopsis only) for preformatted (cat) pages;

[mandoc.git] / term_ascii.c

diff --git a/term_ascii.c b/term_ascii.c
index 7c263cdab0f25254fb13441cf963809087e6b7b5..6c2904537dd13271d6c93a34a4c74803f8b30baa 100644 (file)
--- a/term_ascii.c
+++ b/term_ascii.c
@@ -1,6 +1,7 @@
-/*     $Id: term_ascii.c,v 1.7 2010/06/30 12:27:55 kristaps Exp $ */
+/*     $Id: term_ascii.c,v 1.39 2014/10/28 18:49:33 schwarze Exp $ */

 /*
 /*

- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2014 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
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above


@@ -14,62 +15,113 @@
  * 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"
 #include "config.h"

-#endif

 
 #include <sys/types.h>
 
 #include <assert.h>
 
 #include <sys/types.h>
 
 #include <assert.h>

+#if HAVE_WCHAR
+#include <locale.h>
+#endif

 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>

+#if HAVE_WCHAR
+#include <wchar.h>
+#endif

 
 

+#include "mandoc.h"
+#include "mandoc_aux.h"

 #include "out.h"
 #include "term.h"
 #include "main.h"
 
 #include "out.h"
 #include "term.h"
 #include "main.h"
 

-static size_t            ascii_hspan(const struct termp *,
+static struct termp     *ascii_init(enum termenc,
+                               const struct mchars *, char *);
+static double            ascii_hspan(const struct termp *,

                                const struct roffsu *);
                                const struct roffsu *);

-static size_t            ascii_width(const struct termp *, char);
+static size_t            ascii_width(const struct termp *, int);

 static void              ascii_advance(struct termp *, size_t);
 static void              ascii_begin(struct termp *);
 static void              ascii_end(struct termp *);
 static void              ascii_endline(struct termp *);
 static void              ascii_advance(struct termp *, size_t);
 static void              ascii_begin(struct termp *);
 static void              ascii_end(struct termp *);
 static void              ascii_endline(struct termp *);

-static void              ascii_letter(struct termp *, char);
+static void              ascii_letter(struct termp *, int);
+static void              ascii_setwidth(struct termp *, int, size_t);
+
+#if HAVE_WCHAR
+static void              locale_advance(struct termp *, size_t);
+static void              locale_endline(struct termp *);
+static void              locale_letter(struct termp *, int);
+static size_t            locale_width(const struct termp *, int);
+#endif

 
 
 
 

-void *
-ascii_alloc(char *outopts)
+static struct termp *
+ascii_init(enum termenc enc, const struct mchars *mchars, char *outopts)

 {
 {

-       struct termp    *p;
-       const char      *toks[2];
+       const char      *toks[5];

        char            *v;
        char            *v;

+       struct termp    *p;

 
 

-       if (NULL == (p = term_alloc(TERMENC_ASCII)))
-               return(NULL);
+       p = mandoc_calloc(1, sizeof(struct termp));

 
 

+       p->symtab = mchars;

        p->tabwidth = 5;
        p->tabwidth = 5;

-       p->defrmargin = 78;
+       p->defrmargin = p->lastrmargin = 78;

 
 

-       p->advance = ascii_advance;

        p->begin = ascii_begin;
        p->end = ascii_end;
        p->begin = ascii_begin;
        p->end = ascii_end;

-       p->endline = ascii_endline;

        p->hspan = ascii_hspan;
        p->hspan = ascii_hspan;

-       p->letter = ascii_letter;

        p->type = TERMTYPE_CHAR;
        p->type = TERMTYPE_CHAR;

+
+       p->enc = TERMENC_ASCII;
+       p->advance = ascii_advance;
+       p->endline = ascii_endline;
+       p->letter = ascii_letter;
+       p->setwidth = ascii_setwidth;

        p->width = ascii_width;
 
        p->width = ascii_width;
 

-       toks[0] = "width";
-       toks[1] = NULL;
+#if HAVE_WCHAR
+       if (TERMENC_ASCII != enc) {
+               v = TERMENC_LOCALE == enc ?
+                   setlocale(LC_ALL, "") :
+                   setlocale(LC_CTYPE, "en_US.UTF-8");
+               if (NULL != v && MB_CUR_MAX > 1) {
+                       p->enc = enc;
+                       p->advance = locale_advance;
+                       p->endline = locale_endline;
+                       p->letter = locale_letter;
+                       p->width = locale_width;
+               }
+       }
+#endif
+
+       toks[0] = "indent";
+       toks[1] = "width";
+       toks[2] = "mdoc";
+       toks[3] = "synopsis";
+       toks[4] = NULL;

 
        while (outopts && *outopts)
                switch (getsubopt(&outopts, UNCONST(toks), &v)) {
 
        while (outopts && *outopts)
                switch (getsubopt(&outopts, UNCONST(toks), &v)) {

-               case (0):
+               case 0:
+                       p->defindent = (size_t)atoi(v);
+                       break;
+               case 1:

                        p->defrmargin = (size_t)atoi(v);
                        break;
                        p->defrmargin = (size_t)atoi(v);
                        break;

+               case 2:
+                       /*
+                        * Temporary, undocumented mode
+                        * to imitate mdoc(7) output style.
+                        */
+                       p->mdocstyle = 1;
+                       p->defindent = 5;
+                       break;
+               case 3:
+                       p->synopsisonly = 1;
+                       break;

                default:
                        break;
                }
                default:
                        break;
                }


@@ -81,16 +133,49 @@ ascii_alloc(char *outopts)
        return(p);
 }
 
        return(p);
 }
 

+void *
+ascii_alloc(const struct mchars *mchars, char *outopts)
+{
+
+       return(ascii_init(TERMENC_ASCII, mchars, outopts));
+}
+
+void *
+utf8_alloc(const struct mchars *mchars, char *outopts)
+{
+
+       return(ascii_init(TERMENC_UTF8, mchars, outopts));
+}
+
+void *
+locale_alloc(const struct mchars *mchars, char *outopts)
+{
+
+       return(ascii_init(TERMENC_LOCALE, mchars, outopts));
+}
+
+static void
+ascii_setwidth(struct termp *p, int iop, size_t width)
+{
+
+       p->rmargin = p->defrmargin;
+       if (0 < iop)
+               p->defrmargin += width;
+       else if (0 > iop)
+               p->defrmargin -= width;
+       else
+               p->defrmargin = width ? width : p->lastrmargin;
+       p->lastrmargin = p->rmargin;
+       p->rmargin = p->maxrmargin = p->defrmargin;
+}

 
 

-/* ARGSUSED */

 static size_t
 static size_t

-ascii_width(const struct termp *p, char c)
+ascii_width(const struct termp *p, int c)

 {
 
        return(1);
 }
 
 {
 
        return(1);
 }
 

-

 void
 ascii_free(void *arg)
 {
 void
 ascii_free(void *arg)
 {


@@ -98,16 +183,13 @@ ascii_free(void *arg)
        term_free((struct termp *)arg);
 }
 
        term_free((struct termp *)arg);
 }
 

-
-/* ARGSUSED */

 static void
 static void

-ascii_letter(struct termp *p, char c)
+ascii_letter(struct termp *p, int c)

 {
 {

-       
+

        putchar(c);
 }
 
        putchar(c);
 }
 

-

 static void
 ascii_begin(struct termp *p)
 {
 static void
 ascii_begin(struct termp *p)
 {


@@ -115,7 +197,6 @@ ascii_begin(struct termp *p)
        (*p->headf)(p, p->argf);
 }
 
        (*p->headf)(p, p->argf);
 }
 

-

 static void
 ascii_end(struct termp *p)
 {
 static void
 ascii_end(struct termp *p)
 {


@@ -123,8 +204,6 @@ ascii_end(struct termp *p)
        (*p->footf)(p, p->argf);
 }
 
        (*p->footf)(p, p->argf);
 }
 

-
-/* ARGSUSED */

 static void
 ascii_endline(struct termp *p)
 {
 static void
 ascii_endline(struct termp *p)
 {


@@ -132,60 +211,173 @@ ascii_endline(struct termp *p)
        putchar('\n');
 }
 
        putchar('\n');
 }
 

-
-/* ARGSUSED */

 static void
 ascii_advance(struct termp *p, size_t len)
 {
 static void
 ascii_advance(struct termp *p, size_t len)
 {

-       size_t          i;
+       size_t          i;

 
 

-       /* Just print whitespace on the terminal. */

        for (i = 0; i < len; i++)
                putchar(' ');
 }
 
        for (i = 0; i < len; i++)
                putchar(' ');
 }
 

-
-/* ARGSUSED */
-static size_t
+static double

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

-        * Approximate based on character width.  These are generated
-        * entirely by eyeballing the screen, but appear to be correct.
+        * Approximate based on character width.
+        * None of these will be actually correct given that an inch on
+        * the screen depends on character size, terminal, etc., etc.

         */
         */

-

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

-       case (SCALE_CM):
-               r = 4 * su->scale;
+       case SCALE_BU:
+               r = su->scale * 10.0 / 240.0;

                break;
                break;

-       case (SCALE_IN):
-               r = 10 * su->scale;
+       case SCALE_CM:
+               r = su->scale * 10.0 / 2.54;

                break;
                break;

-       case (SCALE_PC):
-               r = (10 * su->scale) / 6;
+       case SCALE_FS:
+               r = su->scale * 2730.666;

                break;
                break;

-       case (SCALE_PT):
-               r = (10 * su->scale) / 72;
+       case SCALE_IN:
+               r = su->scale * 10.0;

                break;
                break;

-       case (SCALE_MM):
-               r = su->scale / 1000;
+       case SCALE_MM:
+               r = su->scale / 100.0;

                break;
                break;

-       case (SCALE_VS):
-               r = su->scale * 2 - 1;
+       case SCALE_PC:
+               r = su->scale * 10.0 / 6.0;

                break;
                break;

-       default:
+       case SCALE_PT:
+               r = su->scale * 10.0 / 72.0;
+               break;
+       case SCALE_VS:
+               r = su->scale * 2.0 - 1.0;
+               break;
+       case SCALE_EN:
+               /* FALLTHROUGH */
+       case SCALE_EM:

                r = su->scale;
                break;
                r = su->scale;
                break;

+       default:
+               abort();
+               /* NOTREACHED */

        }
 
        }
 

-       /* Explicitly disallow negative values. */
+       return(r);
+}

 
 

-       if (r < 0.0)
-               r = 0.0;
+const char *
+ascii_uc2str(int uc)
+{
+       static const char nbrsp[2] = { ASCII_NBRSP, '\0' };
+       static const char *tab[] = {
+       "<NUL>","<SOH>","<STX>","<ETX>","<EOT>","<ENQ>","<ACK>","<BEL>",
+       "<BS>", "\t",   "<LF>", "<VT>", "<FF>", "<CR>", "<SO>", "<SI>",
+       "<DLE>","<DC1>","<DC2>","<DC3>","<DC4>","<NAK>","<SYN>","<ETB>",
+       "<CAN>","<EM>", "<SUB>","<ESC>","<FS>", "<GS>", "<RS>", "<US>",
+       " ",    "!",    "\"",   "#",    "$",    "%",    "&",    "'",
+       "(",    ")",    "*",    "+",    ",",    "-",    ".",    "/",
+       "0",    "1",    "2",    "3",    "4",    "5",    "6",    "7",
+       "8",    "9",    ":",    ";",    "<",    "=",    ">",    "?",
+       "@",    "A",    "B",    "C",    "D",    "E",    "F",    "G",
+       "H",    "I",    "J",    "K",    "L",    "M",    "N",    "O",
+       "P",    "Q",    "R",    "S",    "T",    "U",    "V",    "W",
+       "X",    "Y",    "Z",    "[",    "\\",   "]",    "^",    "_",
+       "`",    "a",    "b",    "c",    "d",    "e",    "f",    "g",
+       "h",    "i",    "j",    "k",    "l",    "m",    "n",    "o",
+       "p",    "q",    "r",    "s",    "t",    "u",    "v",    "w",
+       "x",    "y",    "z",    "{",    "|",    "}",    "~",    "<DEL>",
+       "<80>", "<81>", "<82>", "<83>", "<84>", "<85>", "<86>", "<87>",
+       "<88>", "<89>", "<8A>", "<8B>", "<8C>", "<8D>", "<8E>", "<8F>",
+       "<90>", "<91>", "<92>", "<93>", "<94>", "<95>", "<96>", "<97>",
+       "<99>", "<99>", "<9A>", "<9B>", "<9C>", "<9D>", "<9E>", "<9F>",
+       nbrsp,  "!",    "/\bc", "GBP",  "o\bx", "=\bY", "|",    "<sec>",
+       "\"",   "(C)",  "_\ba", "<<",   "~",    "",     "(R)",  "-",
+       "<deg>","+-",   "2",    "3",    "'",    ",\bu", "<par>",".",
+       ",",    "1",    "_\bo", ">>",   "1/4",  "1/2",  "3/4",  "?",
+       "`\bA", "'\bA", "^\bA", "~\bA", "\"\bA","o\bA", "AE",   ",\bC",
+       "`\bE", "'\bE", "^\bE", "\"\bE","`\bI", "'\bI", "^\bI", "\"\bI",
+       "-\bD", "~\bN", "`\bO", "'\bO", "^\bO", "~\bO", "\"\bO","x",
+       "/\bO", "`\bU", "'\bU", "^\bU", "\"\bU","'\bY", "Th",   "ss",
+       "`\ba", "'\ba", "^\ba", "~\ba", "\"\ba","o\ba", "ae",   ",\bc",
+       "`\be", "'\be", "^\be", "\"\be","`\bi", "'\bi", "^\bi", "\"\bi",
+       "d",    "~\bn", "`\bo", "'\bo", "^\bo", "~\bo", "\"\bo","-:-",
+       "/\bo", "`\bu", "'\bu", "^\bu", "\"\bu","'\by", "th",   "\"\by",
+       "A",    "a",    "A",    "a",    "A",    "a",    "'\bC", "'\bc",
+       "^\bC", "^\bc", "C",    "c",    "C",    "c",    "D",    "d",
+       "/\bD", "/\bd", "E",    "e",    "E",    "e",    "E",    "e",
+       "E",    "e",    "E",    "e",    "^\bG", "^\bg", "G",    "g",
+       "G",    "g",    ",\bG", ",\bg", "^\bH", "^\bh", "/\bH", "/\bh",
+       "~\bI", "~\bi", "I",    "i",    "I",    "i",    "I",    "i",
+       "I",    "i",    "IJ",   "ij",   "^\bJ", "^\bj", ",\bK", ",\bk",
+       "q",    "'\bL", "'\bl", ",\bL", ",\bl", "L",    "l",    "L",
+       "l",    "/\bL", "/\bl", "'\bN", "'\bn", ",\bN", ",\bn", "N",
+       "n",    "'n",   "Ng",   "ng",   "O",    "o",    "O",    "o",
+       "O",    "o",    "OE",   "oe",   "'\bR", "'\br", ",\bR", ",\br",
+       "R",    "r",    "'\bS", "'\bs", "^\bS", "^\bs", ",\bS", ",\bs",
+       "S",    "s",    ",\bT", ",\bt", "T",    "t",    "/\bT", "/\bt",
+       "~\bU", "~\bu", "U",    "u",    "U",    "u",    "U",    "u",
+       "U",    "u",    "U",    "u",    "^\bW", "^\bw", "^\bY", "^\by",
+       "\"\bY","'\bZ", "'\bz", "Z",    "z",    "Z",    "z",    "s",
+       "b",    "B",    "B",    "b",    "6",    "6",    "O",    "C",
+       "c",    "D",    "D",    "D",    "d",    "d",    "3",    "@",
+       "E",    "F",    ",\bf", "G",    "G",    "hv",   "I",    "/\bI",
+       "K",    "k",    "/\bl", "l",    "W",    "N",    "n",    "~\bO",
+       "O",    "o",    "OI",   "oi",   "P",    "p",    "YR",   "2",
+       "2",    "SH",   "sh",   "t",    "T",    "t",    "T",    "U",
+       "u",    "Y",    "V",    "Y",    "y",    "/\bZ", "/\bz", "ZH",
+       "ZH",   "zh",   "zh",   "/\b2", "5",    "5",    "ts",   "w",
+       "|",    "||",   "|=",   "!",    "DZ",   "Dz",   "dz",   "LJ",
+       "Lj",   "lj",   "NJ",   "Nj",   "nj",   "A",    "a",    "I",
+       "i",    "O",    "o",    "U",    "u",    "U",    "u",    "U",
+       "u",    "U",    "u",    "U",    "u",    "@",    "A",    "a",
+       "A",    "a",    "AE",   "ae",   "/\bG", "/\bg", "G",    "g",
+       "K",    "k",    "O",    "o",    "O",    "o",    "ZH",   "zh",
+       "j",    "DZ",   "Dz",   "dz",   "'\bG", "'\bg", "HV",   "W",
+       "`\bN", "`\bn", "A",    "a",    "'\bAE","'\bae","O",    "o"};
+
+       assert(uc >= 0);
+       if ((size_t)uc < sizeof(tab)/sizeof(tab[0]))
+               return(tab[uc]);
+       return(mchars_uc2str(uc));
+}

 
 

-       return((size_t)/* LINTED */
-                       r);
+#if HAVE_WCHAR
+static size_t
+locale_width(const struct termp *p, int c)
+{
+       int             rc;
+
+       if (c == ASCII_NBRSP)
+               c = ' ';
+       rc = wcwidth(c);
+       if (rc < 0)
+               rc = 0;
+       return(rc);
+}
+
+static void
+locale_advance(struct termp *p, size_t len)
+{
+       size_t          i;
+
+       for (i = 0; i < len; i++)
+               putwchar(L' ');
+}
+
+static void
+locale_endline(struct termp *p)
+{
+
+       putwchar(L'\n');

 }
 
 }
 

+static void
+locale_letter(struct termp *p, int c)
+{
+
+       putwchar(c);
+}
+#endif