mdw@git.distorted.org.uk Git - sgt/halibut/blob - bk_man.c

   1 /*
   2  * man page backend for Halibut
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <assert.h>
   8 #include "halibut.h"
   9
  10 typedef struct {
  11     wchar_t *th;
  12     int headnumbers;
  13     int mindepth;
  14     char *filename;
  15     int charset;
  16     wchar_t *bullet, *lquote, *rquote;
  17 } manconfig;
  18
  19 static void man_text(FILE *, word *,
  20                      int newline, int quote_props, manconfig *conf);
  21 static void man_codepara(FILE *, word *, int charset);
  22 static int man_convert(wchar_t const *s, int maxlen,
  23                        char **result, int quote_props,
  24                        int charset, charset_state *state);
  25
  26 static manconfig man_configure(paragraph *source) {
  27     paragraph *p;
  28     manconfig ret;
  29
  30     /*
  31      * Defaults.
  32      */
  33     ret.th = NULL;
  34     ret.headnumbers = FALSE;
  35     ret.mindepth = 0;
  36     ret.filename = dupstr("output.1");
  37     ret.charset = CS_ASCII;
  38     ret.bullet = L"\x2022\0o\0\0";
  39     ret.lquote = L"\x2018\0\x2019\0\"\0\"\0\0";
  40     ret.rquote = uadv(ret.lquote);
  41
  42     /*
  43      * Two-pass configuration so that we can pick up global config
  44      * (e.g. `quotes') before having it overridden by specific
  45      * config (`man-quotes'), irrespective of the order in which
  46      * they occur.
  47      */
  48     for (p = source; p; p = p->next) {
  49         if (p->type == para_Config) {
  50             if (!ustricmp(p->keyword, L"quotes")) {
  51                 if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
  52                     ret.lquote = uadv(p->keyword);
  53                     ret.rquote = uadv(ret.lquote);
  54                 }
  55             }
  56         }
  57     }
  58
  59     for (p = source; p; p = p->next) {
  60         if (p->type == para_Config) {
  61             if (!ustricmp(p->keyword, L"man-identity")) {
  62                 wchar_t *wp, *ep;
  63
  64                 wp = uadv(p->keyword);
  65                 ep = wp;
  66                 while (*ep)
  67                     ep = uadv(ep);
  68                 sfree(ret.th);
  69                 ret.th = snewn(ep - wp + 1, wchar_t);
  70                 memcpy(ret.th, wp, (ep - wp + 1) * sizeof(wchar_t));
  71             } else if (!ustricmp(p->keyword, L"man-charset")) {
  72                 ret.charset = charset_from_ustr(&p->fpos, uadv(p->keyword));
  73             } else if (!ustricmp(p->keyword, L"man-headnumbers")) {
  74                 ret.headnumbers = utob(uadv(p->keyword));
  75             } else if (!ustricmp(p->keyword, L"man-mindepth")) {
  76                 ret.mindepth = utoi(uadv(p->keyword));
  77             } else if (!ustricmp(p->keyword, L"man-filename")) {
  78                 sfree(ret.filename);
  79                 ret.filename = dupstr(adv(p->origkeyword));
  80             } else if (!ustricmp(p->keyword, L"man-bullet")) {
  81                 ret.bullet = uadv(p->keyword);
  82             } else if (!ustricmp(p->keyword, L"man-quotes")) {
  83                 if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
  84                     ret.lquote = uadv(p->keyword);
  85                     ret.rquote = uadv(ret.lquote);
  86                 }
  87             }
  88         }
  89     }
  90
  91     /*
  92      * Now process fallbacks on quote characters and bullets.
  93      */
  94     while (*uadv(ret.rquote) && *uadv(uadv(ret.rquote)) &&
  95            (!cvt_ok(ret.charset, ret.lquote) ||
  96             !cvt_ok(ret.charset, ret.rquote))) {
  97         ret.lquote = uadv(ret.rquote);
  98         ret.rquote = uadv(ret.lquote);
  99     }
 100
 101     while (*ret.bullet && *uadv(ret.bullet) &&
 102            !cvt_ok(ret.charset, ret.bullet))
 103         ret.bullet = uadv(ret.bullet);
 104
 105     return ret;
 106 }
 107
 108 static void man_conf_cleanup(manconfig cf)
 109 {
 110     sfree(cf.th);
 111     sfree(cf.filename);
 112 }
 113
 114 paragraph *man_config_filename(char *filename)
 115 {
 116     return cmdline_cfg_simple("man-filename", filename, NULL);
 117 }
 118
 119 #define QUOTE_INITCTRL 1 /* quote initial . and ' on a line */
 120 #define QUOTE_QUOTES   2 /* quote double quotes by doubling them */
 121
 122 void man_backend(paragraph *sourceform, keywordlist *keywords,
 123                  indexdata *idx, void *unused) {
 124     paragraph *p;
 125     FILE *fp;
 126     manconfig conf;
 127     int had_described_thing;
 128
 129     IGNORE(unused);
 130     IGNORE(keywords);
 131     IGNORE(idx);
 132
 133     conf = man_configure(sourceform);
 134
 135     /*
 136      * Open the output file.
 137      */
 138     fp = fopen(conf.filename, "w");
 139     if (!fp) {
 140         error(err_cantopenw, conf.filename);
 141         return;
 142     }
 143
 144     /* Do the version ID */
 145     for (p = sourceform; p; p = p->next)
 146         if (p->type == para_VersionID) {
 147             fprintf(fp, ".\\\" ");
 148             man_text(fp, p->words, TRUE, 0, &conf);
 149         }
 150
 151     /* .TH name-of-program manual-section */
 152     fprintf(fp, ".TH");
 153     if (conf.th && *conf.th) {
 154         char *c;
 155         wchar_t *wp;
 156
 157         for (wp = conf.th; *wp; wp = uadv(wp)) {
 158             fputs(" \"", fp);
 159             man_convert(wp, 0, &c, QUOTE_QUOTES, conf.charset, NULL);
 160             fputs(c, fp);
 161             sfree(c);
 162             fputc('"', fp);
 163         }
 164     }
 165     fputc('\n', fp);
 166
 167     had_described_thing = FALSE;
 168 #define cleanup_described_thing do { \
 169     if (had_described_thing) \
 170         fprintf(fp, "\n"); \
 171     had_described_thing = FALSE; \
 172 } while (0)
 173
 174     for (p = sourceform; p; p = p->next) switch (p->type) {
 175         /*
 176          * Things we ignore because we've already processed them or
 177          * aren't going to touch them in this pass.
 178          */
 179       case para_IM:
 180       case para_BR:
 181       case para_Biblio:                /* only touch BiblioCited */
 182       case para_VersionID:
 183       case para_NoCite:
 184       case para_Title:
 185         break;
 186
 187         /*
 188          * Headings.
 189          */
 190       case para_Chapter:
 191       case para_Appendix:
 192       case para_UnnumberedChapter:
 193       case para_Heading:
 194       case para_Subsect:
 195
 196         cleanup_described_thing;
 197         {
 198             int depth;
 199             if (p->type == para_Subsect)
 200                 depth = p->aux + 1;
 201             else if (p->type == para_Heading)
 202                 depth = 1;
 203             else
 204                 depth = 0;
 205             if (depth >= conf.mindepth) {
 206                 if (depth > conf.mindepth)
 207                     fprintf(fp, ".SS \"");
 208                 else
 209                     fprintf(fp, ".SH \"");
 210                 if (conf.headnumbers && p->kwtext) {
 211                     man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES, &conf);
 212                     fprintf(fp, " ");
 213                 }
 214                 man_text(fp, p->words, FALSE, QUOTE_QUOTES, &conf);
 215                 fprintf(fp, "\"\n");
 216             }
 217             break;
 218         }
 219
 220         /*
 221          * Code paragraphs.
 222          */
 223       case para_Code:
 224         cleanup_described_thing;
 225         fprintf(fp, ".PP\n");
 226         man_codepara(fp, p->words, conf.charset);
 227         break;
 228
 229         /*
 230          * Normal paragraphs.
 231          */
 232       case para_Normal:
 233       case para_Copyright:
 234         cleanup_described_thing;
 235         fprintf(fp, ".PP\n");
 236         man_text(fp, p->words, TRUE, 0, &conf);
 237         break;
 238
 239         /*
 240          * List paragraphs.
 241          */
 242       case para_Description:
 243       case para_BiblioCited:
 244       case para_Bullet:
 245       case para_NumberedList:
 246         if (p->type != para_Description)
 247             cleanup_described_thing;
 248
 249         if (p->type == para_Bullet) {
 250             char *bullettext;
 251             man_convert(conf.bullet, -1, &bullettext, QUOTE_QUOTES,
 252                         conf.charset, NULL);
 253             fprintf(fp, ".IP \"\\fB%s\\fP\"\n", bullettext);
 254             sfree(bullettext);
 255         } else if (p->type == para_NumberedList) {
 256             fprintf(fp, ".IP \"");
 257             man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES, &conf);
 258             fprintf(fp, "\"\n");
 259         } else if (p->type == para_Description) {
 260             if (had_described_thing) {
 261                 /*
 262                  * Do nothing; the .xP for this paragraph is the
 263                  * .IP which has come before it in the
 264                  * DescribedThing.
 265                  */
 266             } else {
 267                 /*
 268                  * A \dd without a preceding \dt is given a blank
 269                  * one.
 270                  */
 271                 fprintf(fp, ".IP \"\"\n");
 272             }
 273         } else if (p->type == para_BiblioCited) {
 274             fprintf(fp, ".IP \"");
 275             man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES, &conf);
 276             fprintf(fp, "\"\n");
 277         }
 278         man_text(fp, p->words, TRUE, 0, &conf);
 279         had_described_thing = FALSE;
 280         break;
 281
 282       case para_DescribedThing:
 283         cleanup_described_thing;
 284         fprintf(fp, ".IP \"");
 285         man_text(fp, p->words, FALSE, QUOTE_QUOTES, &conf);
 286         fprintf(fp, "\"\n");
 287         had_described_thing = TRUE;
 288         break;
 289
 290       case para_Rule:
 291         /*
 292          * New paragraph containing a horizontal line 1/2em above the
 293          * baseline whose length is the line length minus the current
 294          * indent.
 295          */
 296         cleanup_described_thing;
 297         fprintf(fp, ".PP\n\\u\\l'\\n(.lu-\\n(.iu'\\d\n");
 298         break;
 299
 300       case para_LcontPush:
 301       case para_QuotePush:
 302         cleanup_described_thing;
 303         fprintf(fp, ".RS\n");
 304         break;
 305       case para_LcontPop:
 306       case para_QuotePop:
 307         cleanup_described_thing;
 308         fprintf(fp, ".RE\n");
 309         break;
 310     }
 311     cleanup_described_thing;
 312
 313     /*
 314      * Tidy up.
 315      */
 316     fclose(fp);
 317     man_conf_cleanup(conf);
 318 }
 319
 320 /*
 321  * Convert a wide string into a string of chars; mallocs the
 322  * resulting string and stores a pointer to it in `*result'.
 323  *
 324  * If `state' is non-NULL, updates the charset state pointed to. If
 325  * `state' is NULL, this function uses its own state, initialises
 326  * it from scratch, and cleans it up when finished. If `state' is
 327  * non-NULL but _s_ is NULL, cleans up a provided state.
 328  *
 329  * Return is nonzero if all characters are OK. If not all
 330  * characters are OK but `result' is non-NULL, a result _will_
 331  * still be generated!
 332  *
 333  * This function also does escaping of groff special characters.
 334  */
 335 static int man_convert(wchar_t const *s, int maxlen,
 336                        char **result, int quote_props,
 337                        int charset, charset_state *state) {
 338     charset_state internal_state = CHARSET_INIT_STATE;
 339     int slen, err;
 340     char *p = NULL, *q;
 341     int plen = 0, psize = 0;
 342     rdstringc out = {0, 0, NULL};
 343
 344     if (!state)
 345         state = &internal_state;
 346
 347     slen = (s ? ustrlen(s) : 0);
 348
 349     if (slen > maxlen && maxlen > 0)
 350         slen = maxlen;
 351
 352     psize = 384;
 353     plen = 0;
 354     p = snewn(psize, char);
 355     err = 0;
 356
 357     while (slen > 0) {
 358         int ret = charset_from_unicode(&s, &slen, p+plen, psize-plen,
 359                                    charset, state, (err ? NULL : &err));
 360         if (ret > 0) {
 361             plen += ret;
 362             if (psize - plen < 256) {
 363                 psize = plen + 256;
 364                 p = sresize(p, psize, char);
 365             }
 366         }
 367     }
 368
 369     if (state == &internal_state || s == NULL) {
 370         int ret = charset_from_unicode(NULL, 0, p+plen, psize-plen,
 371                                        charset, state, NULL);
 372         if (ret > 0)
 373             plen += ret;
 374     }
 375
 376     for (q = p; q < p+plen; q++) {
 377         if (q == p && (*q == '.' || *q == '\'') &&
 378             (quote_props & QUOTE_INITCTRL)) {
 379             /*
 380              * Control character (. or ') at the start of a
 381              * line. Quote it by putting \& (troff zero-width
 382              * space) before it.
 383              */
 384             rdaddc(&out, '\\');
 385             rdaddc(&out, '&');
 386         } else if (*q == '\\') {
 387             /*
 388              * Quote backslashes by doubling them, always.
 389              */
 390             rdaddc(&out, '\\');
 391         } else if (*q == '"' && (quote_props & QUOTE_QUOTES)) {
 392             /*
 393              * Double quote within double quotes. Quote it by
 394              * doubling.
 395              */
 396             rdaddc(&out, '"');
 397         }
 398         rdaddc(&out, *q);
 399     }
 400
 401     sfree(p);
 402
 403     if (out.text)
 404         *result = rdtrimc(&out);
 405     else
 406         *result = dupstr("");
 407
 408     return !err;
 409 }
 410
 411 static int man_rdaddwc(rdstringc *rs, word *text, word *end,
 412                        int quote_props, manconfig *conf,
 413                        charset_state *state) {
 414     char *c;
 415
 416     for (; text && text != end; text = text->next) switch (text->type) {
 417       case word_HyperLink:
 418       case word_HyperEnd:
 419       case word_UpperXref:
 420       case word_LowerXref:
 421       case word_XrefEnd:
 422       case word_IndexRef:
 423         break;
 424
 425       case word_Normal:
 426       case word_Emph:
 427       case word_Code:
 428       case word_WeakCode:
 429       case word_WhiteSpace:
 430       case word_EmphSpace:
 431       case word_CodeSpace:
 432       case word_WkCodeSpace:
 433       case word_Quote:
 434       case word_EmphQuote:
 435       case word_CodeQuote:
 436       case word_WkCodeQuote:
 437         assert(text->type != word_CodeQuote &&
 438                text->type != word_WkCodeQuote);
 439
 440         if (towordstyle(text->type) == word_Emph &&
 441             (attraux(text->aux) == attr_First ||
 442              attraux(text->aux) == attr_Only)) {
 443             man_convert(NULL, 0, &c, quote_props, conf->charset, state);
 444             rdaddsc(rs, c);
 445             if (*c)
 446                 quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 447             sfree(c);
 448             *state = charset_init_state;
 449             rdaddsc(rs, "\\fI");
 450         } else if ((towordstyle(text->type) == word_Code ||
 451                     towordstyle(text->type) == word_WeakCode) &&
 452                    (attraux(text->aux) == attr_First ||
 453                     attraux(text->aux) == attr_Only)) {
 454             man_convert(NULL, 0, &c, quote_props, conf->charset, state);
 455             rdaddsc(rs, c);
 456             if (*c)
 457                 quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 458             sfree(c);
 459             *state = charset_init_state;
 460             rdaddsc(rs, "\\fB");
 461         }
 462
 463         if (removeattr(text->type) == word_Normal) {
 464             charset_state s2 = *state;
 465
 466             if (man_convert(text->text, 0, &c, quote_props, conf->charset, &s2) ||
 467                 !text->alt) {
 468                 rdaddsc(rs, c);
 469                 if (*c)
 470                     quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 471                 *state = s2;
 472             } else {
 473                 quote_props = man_rdaddwc(rs, text->alt, NULL,
 474                                           quote_props, conf, state);
 475             }
 476             sfree(c);
 477         } else if (removeattr(text->type) == word_WhiteSpace) {
 478             man_convert(L" ", 1, &c, quote_props, conf->charset, state);
 479             rdaddsc(rs, c);
 480             if (*c)
 481                 quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 482             sfree(c);
 483         } else if (removeattr(text->type) == word_Quote) {
 484             man_convert(quoteaux(text->aux) == quote_Open ?
 485                         conf->lquote : conf->rquote, 0,
 486                         &c, quote_props, conf->charset, state);
 487             rdaddsc(rs, c);
 488             if (*c)
 489                 quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 490             sfree(c);
 491         }
 492         if (towordstyle(text->type) != word_Normal &&
 493             (attraux(text->aux) == attr_Last ||
 494              attraux(text->aux) == attr_Only)) {
 495             man_convert(NULL, 0, &c, quote_props, conf->charset, state);
 496             rdaddsc(rs, c);
 497             if (*c)
 498                 quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 499             sfree(c);
 500             *state = charset_init_state;
 501             rdaddsc(rs, "\\fP");
 502         }
 503         break;
 504     }
 505     man_convert(NULL, 0, &c, quote_props, conf->charset, state);
 506     rdaddsc(rs, c);
 507     if (*c)
 508         quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 509     sfree(c);
 510
 511     return quote_props;
 512 }
 513
 514 static void man_text(FILE *fp, word *text, int newline,
 515                      int quote_props, manconfig *conf) {
 516     rdstringc t = { 0, 0, NULL };
 517     charset_state state = CHARSET_INIT_STATE;
 518
 519     man_rdaddwc(&t, text, NULL, quote_props | QUOTE_INITCTRL, conf, &state);
 520     fprintf(fp, "%s", t.text);
 521     sfree(t.text);
 522     if (newline)
 523         fputc('\n', fp);
 524 }
 525
 526 static void man_codepara(FILE *fp, word *text, int charset) {
 527     fprintf(fp, ".nf\n");
 528     for (; text; text = text->next) if (text->type == word_WeakCode) {
 529         char *c;
 530         wchar_t *t, *e;
 531         int quote_props = QUOTE_INITCTRL;
 532
 533         t = text->text;
 534         if (text->next && text->next->type == word_Emph) {
 535             e = text->next->text;
 536             text = text->next;
 537         } else
 538             e = NULL;
 539
 540         while (e && *e && *t) {
 541             int n;
 542             int ec = *e;
 543
 544             for (n = 0; t[n] && e[n] && e[n] == ec; n++);
 545             if (ec == 'i')
 546                 fprintf(fp, "\\fI");
 547             else if (ec == 'b')
 548                 fprintf(fp, "\\fB");
 549             man_convert(t, n, &c, quote_props, charset, NULL);
 550             quote_props &= ~QUOTE_INITCTRL;
 551             fprintf(fp, "%s", c);
 552             sfree(c);
 553             if (ec == 'i' || ec == 'b')
 554                 fprintf(fp, "\\fP");
 555             t += n;
 556             e += n;
 557         }
 558         man_convert(t, 0, &c, quote_props, charset, NULL);
 559         fprintf(fp, "%s\n", c);
 560         sfree(c);
 561     }
 562     fprintf(fp, ".fi\n");
 563 }