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, *rule, *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 /*
  27  * My TROFF reference is "NROFF/TROFF User's Manual", Joseph
  28  * F. Ossana, October 11 1976.
  29  *
  30  * not yet used:
  31  * \(ru  rule
  32  * \(pl  math plus
  33  * \(mi  math minus
  34  * \(eq  math equals
  35  * \(ga  grave accent
  36  * \(ul  underrule
  37  * \(sl  slash (matching bakslash)
  38  * \(br  box vertical rule
  39  * \(br  Bell System logo
  40  * \(or  or
  41  * all characters for constructing large brackets
  42  */
  43
  44 static struct {
  45     unsigned short uni;
  46     char const *troff;
  47 } const man_charmap[] = {
  48     {0x00A2, "\\(ct"}, {0x00A7, "\\(sc"}, {0x00A9, "\\(co"}, {0x00AC, "\\(no"},
  49     {0x00AE, "\\(rg"}, {0x00B0, "\\(de"}, {0x00B1, "\\(+-"}, {0x00B4, "\\(aa"},
  50     {0x00BC, "\\(14"}, {0x00BD, "\\(12"}, {0x00BE, "\\(34"}, {0x00D7, "\\(mu"},
  51     {0x00F7, "\\(di"},
  52
  53     {0x0391, "\\(*A"}, {0x0392, "\\(*B"}, {0x0393, "\\(*G"}, {0x0394, "\\(*D"},
  54     {0x0395, "\\(*E"}, {0x0396, "\\(*Z"}, {0x0397, "\\(*Y"}, {0x0398, "\\(*H"},
  55     {0x0399, "\\(*I"}, {0x039A, "\\(*K"}, {0x039B, "\\(*L"}, {0x039C, "\\(*M"},
  56     {0x039D, "\\(*N"}, {0x039E, "\\(*C"}, {0x039F, "\\(*O"}, {0x03A0, "\\(*P"},
  57     {0x03A1, "\\(*R"}, {0x03A3, "\\(*S"}, {0x03A4, "\\(*T"}, {0x03A5, "\\(*U"},
  58     {0x03A6, "\\(*F"}, {0x03A7, "\\(*X"}, {0x03A8, "\\(*Q"}, {0x03A9, "\\(*W"},
  59     {0x03B1, "\\(*a"}, {0x03B2, "\\(*b"}, {0x03B3, "\\(*g"}, {0x03B4, "\\(*d"},
  60     {0x03B5, "\\(*e"}, {0x03B6, "\\(*z"}, {0x03B7, "\\(*y"}, {0x03B8, "\\(*h"},
  61     {0x03B9, "\\(*i"}, {0x03BA, "\\(*k"}, {0x03BB, "\\(*l"}, {0x03BC, "\\(*m"},
  62     {0x03BD, "\\(*n"}, {0x03BE, "\\(*c"}, {0x03BF, "\\(*o"}, {0x03C0, "\\(*p"},
  63     {0x03C1, "\\(*r"}, {0x03C2, "\\(ts"}, {0x03C3, "\\(*s"}, {0x03C4, "\\(*t"},
  64     {0x03C5, "\\(*u"}, {0x03C6, "\\(*f"}, {0x03C7, "\\(*x"}, {0x03C8, "\\(*q"},
  65     {0x03C9, "\\(*w"},
  66
  67     {0x2014, "\\(em"}, {0x2018, "`"},     {0x2019, "'"},     {0x2020, "\\(dg"},
  68     {0x2021, "\\(dd"}, {0x2022, "\\(bu"}, {0x2032, "\\(fm"},
  69
  70     {0x2190, "\\(<-"}, {0x2191, "\\(ua"}, {0x2192, "\\(->"}, {0x2193, "\\(da"},
  71
  72     {0x2202, "\\(pd"}, {0x2205, "\\(es"}, {0x2207, "\\(gr"}, {0x2208, "\\(mo"},
  73     {0x2212, "\\-"},   {0x2217, "\\(**"}, {0x221A, "\\(sr"}, {0x221D, "\\(pt"},
  74     {0x221E, "\\(if"}, {0x2229, "\\(ca"}, {0x222A, "\\(cu"}, {0x222B, "\\(is"},
  75     {0x223C, "\\(ap"}, {0x2245, "\\(~="}, {0x2260, "\\(!="}, {0x2261, "\\(=="},
  76     {0x2264, "\\(<="}, {0x2265, "\\(>="}, {0x2282, "\\(sb"}, {0x2283, "\\(sp"},
  77     {0x2286, "\\(ib"}, {0x2287, "\\(ip"},
  78
  79     {0x25A1, "\\(sq"},  {0x25CB, "\\(ci"},
  80
  81     {0x261C, "\\(lh"},  {0x261E, "\\(rh"},
  82 };
  83
  84 static char const *troffchar(int unichar) {
  85     int i, j, k;
  86
  87     i = -1;
  88     j = lenof(man_charmap);
  89     while (j-i > 1) {
  90         k = (i + j) / 2;
  91         if (man_charmap[k].uni == unichar)
  92             return man_charmap[k].troff;
  93         else if (man_charmap[k].uni > unichar)
  94             j = k;
  95         else
  96             i = k;
  97     }
  98     return NULL;
  99 }
 100
 101 /*
 102  * Return TRUE if we can represent the whole of the given string either
 103  * in the output charset or as named characters; FALSE otherwise.
 104  */
 105 static int troff_ok(int charset, wchar_t *string) {
 106     wchar_t test[2];
 107     while (*string) {
 108         test[0] = *string;
 109         test[1] = 0;
 110         if (!cvt_ok(charset, test) && !troffchar(*string))
 111             return FALSE;
 112         string++;
 113     }
 114     return TRUE;
 115 }
 116
 117 static manconfig man_configure(paragraph *source) {
 118     paragraph *p;
 119     manconfig ret;
 120
 121     /*
 122      * Defaults.
 123      */
 124     ret.th = NULL;
 125     ret.headnumbers = FALSE;
 126     ret.mindepth = 0;
 127     ret.filename = dupstr("output.1");
 128     ret.charset = CS_ASCII;
 129     ret.bullet = L"\x2022\0o\0\0";
 130     ret.rule = L"\x2500\0-\0\0";
 131     ret.lquote = L"\x2018\0\x2019\0\"\0\"\0\0";
 132     ret.rquote = uadv(ret.lquote);
 133
 134     /*
 135      * Two-pass configuration so that we can pick up global config
 136      * (e.g. `quotes') before having it overridden by specific
 137      * config (`man-quotes'), irrespective of the order in which
 138      * they occur.
 139      */
 140     for (p = source; p; p = p->next) {
 141         if (p->type == para_Config) {
 142             if (!ustricmp(p->keyword, L"quotes")) {
 143                 if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
 144                     ret.lquote = uadv(p->keyword);
 145                     ret.rquote = uadv(ret.lquote);
 146                 }
 147             }
 148         }
 149     }
 150
 151     for (p = source; p; p = p->next) {
 152         if (p->type == para_Config) {
 153             if (!ustricmp(p->keyword, L"man-identity")) {
 154                 wchar_t *wp, *ep;
 155
 156                 wp = uadv(p->keyword);
 157                 ep = wp;
 158                 while (*ep)
 159                     ep = uadv(ep);
 160                 sfree(ret.th);
 161                 ret.th = snewn(ep - wp + 1, wchar_t);
 162                 memcpy(ret.th, wp, (ep - wp + 1) * sizeof(wchar_t));
 163             } else if (!ustricmp(p->keyword, L"man-charset")) {
 164                 ret.charset = charset_from_ustr(&p->fpos, uadv(p->keyword));
 165             } else if (!ustricmp(p->keyword, L"man-headnumbers")) {
 166                 ret.headnumbers = utob(uadv(p->keyword));
 167             } else if (!ustricmp(p->keyword, L"man-mindepth")) {
 168                 ret.mindepth = utoi(uadv(p->keyword));
 169             } else if (!ustricmp(p->keyword, L"man-filename")) {
 170                 sfree(ret.filename);
 171                 ret.filename = dupstr(adv(p->origkeyword));
 172             } else if (!ustricmp(p->keyword, L"man-bullet")) {
 173                 ret.bullet = uadv(p->keyword);
 174             } else if (!ustricmp(p->keyword, L"man-rule")) {
 175                 ret.rule = uadv(p->keyword);
 176             } else if (!ustricmp(p->keyword, L"man-quotes")) {
 177                 if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
 178                     ret.lquote = uadv(p->keyword);
 179                     ret.rquote = uadv(ret.lquote);
 180                 }
 181             }
 182         }
 183     }
 184
 185     /*
 186      * Now process fallbacks on quote characters, bullets, and the
 187      * rule character.
 188      */
 189     while (*uadv(ret.rquote) && *uadv(uadv(ret.rquote)) &&
 190            (!troff_ok(ret.charset, ret.lquote) ||
 191             !troff_ok(ret.charset, ret.rquote))) {
 192         ret.lquote = uadv(ret.rquote);
 193         ret.rquote = uadv(ret.lquote);
 194     }
 195
 196     while (*ret.bullet && *uadv(ret.bullet) &&
 197            !troff_ok(ret.charset, ret.bullet))
 198         ret.bullet = uadv(ret.bullet);
 199
 200     while (*ret.rule && *uadv(ret.rule) &&
 201            !troff_ok(ret.charset, ret.rule))
 202         ret.rule = uadv(ret.rule);
 203
 204     return ret;
 205 }
 206
 207 static void man_conf_cleanup(manconfig cf)
 208 {
 209     sfree(cf.th);
 210     sfree(cf.filename);
 211 }
 212
 213 paragraph *man_config_filename(char *filename)
 214 {
 215     return cmdline_cfg_simple("man-filename", filename, NULL);
 216 }
 217
 218 #define QUOTE_INITCTRL    1 /* quote initial . and ' on a line */
 219 #define QUOTE_QUOTES      2 /* quote double quotes by doubling them */
 220 #define QUOTE_LITERAL     4 /* defeat special meaning of `, ', - in troff */
 221
 222 void man_backend(paragraph *sourceform, keywordlist *keywords,
 223                  indexdata *idx, void *unused) {
 224     paragraph *p;
 225     FILE *fp;
 226     manconfig conf;
 227     int had_described_thing;
 228
 229     IGNORE(unused);
 230     IGNORE(keywords);
 231     IGNORE(idx);
 232
 233     conf = man_configure(sourceform);
 234
 235     /*
 236      * Open the output file.
 237      */
 238     fp = fopen(conf.filename, "w");
 239     if (!fp) {
 240         error(err_cantopenw, conf.filename);
 241         return;
 242     }
 243
 244     /* Do the version ID */
 245     for (p = sourceform; p; p = p->next)
 246         if (p->type == para_VersionID) {
 247             fprintf(fp, ".\\\" ");
 248             man_text(fp, p->words, TRUE, 0, &conf);
 249         }
 250
 251     /* .TH name-of-program manual-section */
 252     fprintf(fp, ".TH");
 253     if (conf.th && *conf.th) {
 254         char *c;
 255         wchar_t *wp;
 256
 257         for (wp = conf.th; *wp; wp = uadv(wp)) {
 258             fputs(" \"", fp);
 259             man_convert(wp, 0, &c, QUOTE_QUOTES, conf.charset, NULL);
 260             fputs(c, fp);
 261             sfree(c);
 262             fputc('"', fp);
 263         }
 264     }
 265     fputc('\n', fp);
 266
 267     had_described_thing = FALSE;
 268 #define cleanup_described_thing do { \
 269     if (had_described_thing) \
 270         fprintf(fp, "\n"); \
 271     had_described_thing = FALSE; \
 272 } while (0)
 273
 274     for (p = sourceform; p; p = p->next) switch (p->type) {
 275         /*
 276          * Things we ignore because we've already processed them or
 277          * aren't going to touch them in this pass.
 278          */
 279       case para_IM:
 280       case para_BR:
 281       case para_Biblio:                /* only touch BiblioCited */
 282       case para_VersionID:
 283       case para_NoCite:
 284       case para_Title:
 285         break;
 286
 287         /*
 288          * Headings.
 289          */
 290       case para_Chapter:
 291       case para_Appendix:
 292       case para_UnnumberedChapter:
 293       case para_Heading:
 294       case para_Subsect:
 295
 296         cleanup_described_thing;
 297         {
 298             int depth;
 299             if (p->type == para_Subsect)
 300                 depth = p->aux + 1;
 301             else if (p->type == para_Heading)
 302                 depth = 1;
 303             else
 304                 depth = 0;
 305             if (depth >= conf.mindepth) {
 306                 if (depth > conf.mindepth)
 307                     fprintf(fp, ".SS \"");
 308                 else
 309                     fprintf(fp, ".SH \"");
 310                 if (conf.headnumbers && p->kwtext) {
 311                     man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES, &conf);
 312                     fprintf(fp, " ");
 313                 }
 314                 man_text(fp, p->words, FALSE, QUOTE_QUOTES, &conf);
 315                 fprintf(fp, "\"\n");
 316             }
 317             break;
 318         }
 319
 320         /*
 321          * Code paragraphs.
 322          */
 323       case para_Code:
 324         cleanup_described_thing;
 325         fprintf(fp, ".PP\n");
 326         man_codepara(fp, p->words, conf.charset);
 327         break;
 328
 329         /*
 330          * Normal paragraphs.
 331          */
 332       case para_Normal:
 333       case para_Copyright:
 334         cleanup_described_thing;
 335         fprintf(fp, ".PP\n");
 336         man_text(fp, p->words, TRUE, 0, &conf);
 337         break;
 338
 339         /*
 340          * List paragraphs.
 341          */
 342       case para_Description:
 343       case para_BiblioCited:
 344       case para_Bullet:
 345       case para_NumberedList:
 346         if (p->type != para_Description)
 347             cleanup_described_thing;
 348
 349         if (p->type == para_Bullet) {
 350             char *bullettext;
 351             man_convert(conf.bullet, -1, &bullettext, QUOTE_QUOTES,
 352                         conf.charset, NULL);
 353             fprintf(fp, ".IP \"\\fB%s\\fP\"\n", bullettext);
 354             sfree(bullettext);
 355         } else if (p->type == para_NumberedList) {
 356             fprintf(fp, ".IP \"");
 357             man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES, &conf);
 358             fprintf(fp, "\"\n");
 359         } else if (p->type == para_Description) {
 360             if (had_described_thing) {
 361                 /*
 362                  * Do nothing; the .xP for this paragraph is the
 363                  * .IP which has come before it in the
 364                  * DescribedThing.
 365                  */
 366             } else {
 367                 /*
 368                  * A \dd without a preceding \dt is given a blank
 369                  * one.
 370                  */
 371                 fprintf(fp, ".IP \"\"\n");
 372             }
 373         } else if (p->type == para_BiblioCited) {
 374             fprintf(fp, ".IP \"");
 375             man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES, &conf);
 376             fprintf(fp, "\"\n");
 377         }
 378         man_text(fp, p->words, TRUE, 0, &conf);
 379         had_described_thing = FALSE;
 380         break;
 381
 382       case para_DescribedThing:
 383         cleanup_described_thing;
 384         fprintf(fp, ".IP \"");
 385         man_text(fp, p->words, FALSE, QUOTE_QUOTES, &conf);
 386         fprintf(fp, "\"\n");
 387         had_described_thing = TRUE;
 388         break;
 389
 390       case para_Rule:
 391         {
 392             char *ruletext;
 393             /*
 394              * New paragraph containing a horizontal line 1/2em above
 395              * the baseline, or a line of rule characters, whose
 396              * length is the line length minus the current indent.
 397              */
 398             cleanup_described_thing;
 399             man_convert(conf.rule, -1, &ruletext, 0, conf.charset, NULL);
 400             fprintf(fp, ".PP\n.ie t \\u\\l'\\n(.lu-\\n(.iu'\\d\n"
 401                     ".el \\l'\\n(.lu-\\n(.iu\\&%s'\n", ruletext);
 402             sfree(ruletext);
 403         }
 404         break;
 405
 406       case para_LcontPush:
 407       case para_QuotePush:
 408         cleanup_described_thing;
 409         fprintf(fp, ".RS\n");
 410         break;
 411       case para_LcontPop:
 412       case para_QuotePop:
 413         cleanup_described_thing;
 414         fprintf(fp, ".RE\n");
 415         break;
 416     }
 417     cleanup_described_thing;
 418
 419     /*
 420      * Tidy up.
 421      */
 422     fclose(fp);
 423     man_conf_cleanup(conf);
 424 }
 425
 426 /*
 427  * Convert a wide string into a string of chars; mallocs the
 428  * resulting string and stores a pointer to it in `*result'.
 429  *
 430  * If `state' is non-NULL, updates the charset state pointed to. If
 431  * `state' is NULL, this function uses its own state, initialises
 432  * it from scratch, and cleans it up when finished. If `state' is
 433  * non-NULL but _s_ is NULL, cleans up a provided state.
 434  *
 435  * Return is nonzero if all characters are OK. If not all
 436  * characters are OK but `result' is non-NULL, a result _will_
 437  * still be generated!
 438  *
 439  * This function also does escaping of groff special characters.
 440  */
 441 static int man_convert(wchar_t const *s, int maxlen,
 442                        char **result, int quote_props,
 443                        int charset, charset_state *state) {
 444     charset_state internal_state = CHARSET_INIT_STATE;
 445     int slen, err;
 446     char *p = NULL, *q;
 447     int plen = 0, psize = 0;
 448     rdstringc out = {0, 0, NULL};
 449     int anyerr = 0;
 450
 451     if (!state)
 452         state = &internal_state;
 453
 454     slen = (s ? ustrlen(s) : 0);
 455
 456     if (slen > maxlen && maxlen > 0)
 457         slen = maxlen;
 458
 459     psize = 384;
 460     plen = 0;
 461     p = snewn(psize, char);
 462     err = 0;
 463
 464     while (slen > 0) {
 465         int ret = charset_from_unicode(&s, &slen, p, psize,
 466                                    charset, state, &err);
 467         plen = ret;
 468
 469         for (q = p; q < p+plen; q++) {
 470             if (q == p && (*q == '.' || *q == '\'') &&
 471                 (quote_props & QUOTE_INITCTRL)) {
 472                 /*
 473                  * Control character (. or ') at the start of a
 474                  * line. Quote it by putting \& (troff zero-width
 475                  * space) before it.
 476                  */
 477                 rdaddc(&out, '\\');
 478                 rdaddc(&out, '&');
 479             }
 480             if (*q == '`' || *q == ' ') {
 481                 /* Quote backticks and nonbreakable spaces always. */
 482                 rdaddc(&out, '\\');
 483             } else if (*q == '\\') {
 484                 /* Turn backslashes into \e. */
 485                 rdaddsc(&out, "\\e");
 486                 continue;
 487             } else if (*q == '-' && !(quote_props & QUOTE_LITERAL)) {
 488                 /* Turn nonbreakable hyphens into \(hy. */
 489                 rdaddsc(&out, "\\(hy");
 490                 continue;
 491             } else if (*q == '\'' && (quote_props & QUOTE_LITERAL)) {
 492                 /* Try to preserve literal U+0027 */
 493                 rdaddsc(&out, "\\(aq"); /* "apostrophe quote" */
 494                 continue;
 495             } else if (*q == '"' && (quote_props & QUOTE_QUOTES)) {
 496                 /*
 497                  * Double quote within double quotes. Quote it by
 498                  * doubling.
 499                  */
 500                 rdaddc(&out, '"');
 501             }
 502             rdaddc(&out, *q);
 503         }
 504         if (err) {
 505             char const *tr = troffchar(*s);
 506             if (tr == NULL)
 507                 anyerr = TRUE;
 508             else
 509                 rdaddsc(&out, tr);
 510             s++; slen--;
 511         }
 512         /* Past start of string -- no more quoting needed */
 513         quote_props &= ~QUOTE_INITCTRL;
 514     }
 515
 516     if (state == &internal_state || s == NULL) {
 517         int ret = charset_from_unicode(NULL, 0, p+plen, psize-plen,
 518                                        charset, state, NULL);
 519         if (ret > 0)
 520             plen += ret;
 521     }
 522
 523     sfree(p);
 524
 525     if (out.text)
 526         *result = rdtrimc(&out);
 527     else
 528         *result = dupstr("");
 529
 530     return !anyerr;
 531 }
 532
 533 static int man_rdaddwc_reset(rdstringc *rs, int quote_props, manconfig *conf,
 534                              charset_state *state) {
 535     char *c;
 536
 537     man_convert(NULL, 0, &c, quote_props, conf->charset, state);
 538     rdaddsc(rs, c);
 539     if (*c)
 540         quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 541     sfree(c);
 542     *state = charset_init_state;
 543     return quote_props;
 544 }
 545
 546 static int man_rdaddctrl(rdstringc *rs, char *c, int quote_props,
 547                          manconfig *conf, charset_state *state) {
 548     quote_props = man_rdaddwc_reset(rs, quote_props, conf, state);
 549     rdaddsc(rs, c);
 550     return quote_props;
 551 }
 552
 553 static int man_rdaddwc(rdstringc *rs, word *text, word *end,
 554                        int quote_props, manconfig *conf,
 555                        charset_state *state) {
 556     char *c;
 557
 558     for (; text && text != end; text = text->next) switch (text->type) {
 559       case word_HyperLink:
 560       case word_HyperEnd:
 561       case word_UpperXref:
 562       case word_LowerXref:
 563       case word_XrefEnd:
 564       case word_IndexRef:
 565         break;
 566
 567       case word_Normal:
 568       case word_Emph:
 569       case word_Code:
 570       case word_WeakCode:
 571       case word_WhiteSpace:
 572       case word_EmphSpace:
 573       case word_CodeSpace:
 574       case word_WkCodeSpace:
 575       case word_Quote:
 576       case word_EmphQuote:
 577       case word_CodeQuote:
 578       case word_WkCodeQuote:
 579         assert(text->type != word_CodeQuote &&
 580                text->type != word_WkCodeQuote);
 581
 582         if (towordstyle(text->type) == word_Emph &&
 583             (attraux(text->aux) == attr_First ||
 584              attraux(text->aux) == attr_Only)) {
 585             quote_props = man_rdaddctrl(rs, "\\fI", quote_props, conf, state);
 586         } else if ((towordstyle(text->type) == word_Code ||
 587                     towordstyle(text->type) == word_WeakCode) &&
 588                    (attraux(text->aux) == attr_First ||
 589                     attraux(text->aux) == attr_Only)) {
 590             quote_props = man_rdaddctrl(rs, "\\fB", quote_props, conf, state);
 591         }
 592
 593         if (towordstyle(text->type) == word_Code ||
 594             towordstyle(text->type) == word_WeakCode)
 595             quote_props |= QUOTE_LITERAL;
 596
 597         if (removeattr(text->type) == word_Normal) {
 598             charset_state s2 = *state;
 599             int len = ustrlen(text->text), hyphen = FALSE;
 600
 601             if (text->breaks && text->text[len - 1] == '-') {
 602                 len--;
 603                 hyphen = TRUE;
 604             }
 605             if (len == 0 ||
 606                 man_convert(text->text, len, &c, quote_props, conf->charset,
 607                             &s2) ||
 608                 !text->alt) {
 609                 if (len != 0) {
 610                     rdaddsc(rs, c);
 611                     if (*c)
 612                         quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 613                     *state = s2;
 614                 }
 615                 if (hyphen) {
 616                     quote_props =
 617                         man_rdaddctrl(rs, "-", quote_props, conf, state);
 618                     quote_props &= ~QUOTE_INITCTRL;
 619                 }
 620             } else {
 621                 quote_props = man_rdaddwc(rs, text->alt, NULL,
 622                                           quote_props, conf, state);
 623             }
 624             if (len != 0)
 625                 sfree(c);
 626         } else if (removeattr(text->type) == word_WhiteSpace) {
 627             quote_props = man_rdaddctrl(rs, " ", quote_props, conf, state);
 628             quote_props &= ~QUOTE_INITCTRL;
 629         } else if (removeattr(text->type) == word_Quote) {
 630             man_convert(quoteaux(text->aux) == quote_Open ?
 631                         conf->lquote : conf->rquote, 0,
 632                         &c, quote_props, conf->charset, state);
 633             rdaddsc(rs, c);
 634             if (*c)
 635                 quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
 636             sfree(c);
 637         }
 638         if (towordstyle(text->type) != word_Normal &&
 639             (attraux(text->aux) == attr_Last ||
 640              attraux(text->aux) == attr_Only)) {
 641             quote_props = man_rdaddctrl(rs, "\\fP", quote_props, conf, state);
 642         }
 643         break;
 644     }
 645     quote_props = man_rdaddwc_reset(rs, quote_props, conf, state);
 646
 647     return quote_props;
 648 }
 649
 650 static void man_text(FILE *fp, word *text, int newline,
 651                      int quote_props, manconfig *conf) {
 652     rdstringc t = { 0, 0, NULL };
 653     charset_state state = CHARSET_INIT_STATE;
 654
 655     man_rdaddwc(&t, text, NULL, quote_props | QUOTE_INITCTRL, conf, &state);
 656     fprintf(fp, "%s", t.text);
 657     sfree(t.text);
 658     if (newline)
 659         fputc('\n', fp);
 660 }
 661
 662 static void man_codepara(FILE *fp, word *text, int charset) {
 663     fprintf(fp, ".nf\n");
 664     for (; text; text = text->next) if (text->type == word_WeakCode) {
 665         char *c;
 666         wchar_t *t, *e;
 667         int quote_props = QUOTE_INITCTRL | QUOTE_LITERAL;
 668
 669         t = text->text;
 670         if (text->next && text->next->type == word_Emph) {
 671             e = text->next->text;
 672             text = text->next;
 673         } else
 674             e = NULL;
 675
 676         while (e && *e && *t) {
 677             int n;
 678             int ec = *e;
 679
 680             for (n = 0; t[n] && e[n] && e[n] == ec; n++);
 681             if (ec == 'i')
 682                 fprintf(fp, "\\fI");
 683             else if (ec == 'b')
 684                 fprintf(fp, "\\fB");
 685             man_convert(t, n, &c, quote_props, charset, NULL);
 686             quote_props &= ~QUOTE_INITCTRL;
 687             fprintf(fp, "%s", c);
 688             sfree(c);
 689             if (ec == 'i' || ec == 'b')
 690                 fprintf(fp, "\\fP");
 691             t += n;
 692             e += n;
 693         }
 694         man_convert(t, 0, &c, quote_props, charset, NULL);
 695         fprintf(fp, "%s\n", c);
 696         sfree(c);
 697     }
 698     fprintf(fp, ".fi\n");
 699 }