tr.c

   1 /* built-in troff requests */
   2 #include <ctype.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include "roff.h"
   7
   8 static int tr_nl = 1;           /* just read a newline */
   9 static int c_pc = '%';          /* page number character */
  10 int c_ec = '\\';
  11 int c_cc = '.';
  12 int c_c2 = '\'';
  13
  14 /* skip everything until the end of line */
  15 static void jmp_eol(void)
  16 {
  17         int c;
  18         do {
  19                 c = cp_next();
  20         } while (c >= 0 && c != '\n');
  21 }
  22
  23 static void tr_vs(char **args)
  24 {
  25         int vs = args[1] ? eval_re(args[1], n_v, 'p') : n_v0;
  26         n_v0 = n_v;
  27         n_v = MAX(0, vs);
  28 }
  29
  30 static void tr_ls(char **args)
  31 {
  32         int ls = args[1] ? eval_re(args[1], n_L, 0) : n_L0;
  33         n_L0 = n_L;
  34         n_L = MAX(1, ls);
  35 }
  36
  37 static void tr_pl(char **args)
  38 {
  39         int n = eval_re(args[1] ? args[1] : "11i", n_p, 'v');
  40         n_p = MAX(0, n);
  41 }
  42
  43 static void tr_nr(char **args)
  44 {
  45         int id;
  46         if (!args[2])
  47                 return;
  48         id = map(args[1]);
  49         num_set(id, eval_re(args[2], num_get(id), 'u'));
  50         num_setinc(id, args[3] ? eval(args[3], 'u') : 0);
  51 }
  52
  53 static void tr_rr(char **args)
  54 {
  55         int i;
  56         for (i = 1; i <= NARGS; i++)
  57                 if (args[i])
  58                         num_del(map(args[i]));
  59 }
  60
  61 static void tr_af(char **args)
  62 {
  63         if (args[2])
  64                 num_setfmt(map(args[1]), args[2]);
  65 }
  66
  67 static void tr_ds(char **args)
  68 {
  69         if (args[2])
  70                 str_set(map(args[1]), args[2]);
  71 }
  72
  73 static void tr_as(char **args)
  74 {
  75         int reg;
  76         char *s1, *s2, *s;
  77         if (!args[2])
  78                 return;
  79         reg = map(args[1]);
  80         s1 = str_get(reg) ? str_get(reg) : "";
  81         s2 = args[2];
  82         s = xmalloc(strlen(s1) + strlen(s2) + 1);
  83         strcpy(s, s1);
  84         strcat(s, s2);
  85         str_set(reg, s);
  86         free(s);
  87 }
  88
  89 static void tr_rm(char **args)
  90 {
  91         int i;
  92         for (i = 1; i <= NARGS; i++)
  93                 if (args[i])
  94                         str_rm(map(args[i]));
  95 }
  96
  97 static void tr_rn(char **args)
  98 {
  99         if (!args[2])
 100                 return;
 101         str_rn(map(args[1]), map(args[2]));
 102 }
 103
 104 static void tr_po(char **args)
 105 {
 106         int po = args[1] ? eval_re(args[1], n_o, 'm') : n_o0;
 107         n_o0 = n_o;
 108         n_o = MAX(0, po);
 109 }
 110
 111 static void read_regname(char *s)
 112 {
 113         int c = cp_next();
 114         int n = n_cp ? 2 : NMLEN - 1;
 115         while (c == ' ' || c == '\t' || c == c_ni)
 116                 c = cp_next();
 117         while (c >= 0 && c != ' ' && c != '\t' && c != '\n' && --n >= 0) {
 118                 *s++ = c;
 119                 do {
 120                         c = cp_next();
 121                 } while (n && c == c_ni);
 122         }
 123         if (c >= 0)
 124                 cp_back(c);
 125         *s = '\0';
 126 }
 127
 128 static void macrobody(struct sbuf *sbuf, char *end)
 129 {
 130         char buf[NMLEN];
 131         int i, c;
 132         int first = 1;
 133         cp_back('\n');
 134         cp_copymode(1);
 135         while ((c = cp_next()) >= 0) {
 136                 if (sbuf && !first)
 137                         sbuf_add(sbuf, c);
 138                 first = 0;
 139                 if (c == '\n') {
 140                         if ((c = cp_next()) != '.') {
 141                                 cp_back(c);
 142                                 continue;
 143                         }
 144                         read_regname(buf);
 145                         if ((n_cp && end[0] == buf[0] && end[1] == buf[1]) ||
 146                                                 !strcmp(end, buf)) {
 147                                 for (i = strlen(buf) - 1; i >= 0; i--)
 148                                         cp_back((unsigned char) buf[i]);
 149                                 cp_back('.');
 150                                 break;
 151                         }
 152                         if (sbuf) {
 153                                 sbuf_add(sbuf, '.');
 154                                 for (i = 0; buf[i]; i++)
 155                                         sbuf_add(sbuf, (unsigned char) buf[i]);
 156                         }
 157                 }
 158         }
 159         cp_copymode(0);
 160 }
 161
 162 static void tr_de(char **args)
 163 {
 164         struct sbuf sbuf;
 165         int id;
 166         if (!args[1])
 167                 return;
 168         id = map(args[1]);
 169         sbuf_init(&sbuf);
 170         if (args[0][1] == 'a' && args[0][2] == 'm' && str_get(id))
 171                 sbuf_append(&sbuf, str_get(id));
 172         macrobody(&sbuf, args[2] ? args[2] : ".");
 173         str_set(id, sbuf_buf(&sbuf));
 174         sbuf_done(&sbuf);
 175 }
 176
 177 static void tr_ig(char **args)
 178 {
 179         macrobody(NULL, args[1] ? args[1] : ".");
 180 }
 181
 182 /* read into sbuf until stop; if stop is NULL, stop at whitespace */
 183 static int read_until(struct sbuf *sbuf, char *stop,
 184                         int (*next)(void), void (*back)(int))
 185 {
 186         char cs[GNLEN], cs2[GNLEN];
 187         int c;
 188         while ((c = next()) >= 0) {
 189                 if (c == c_ni)
 190                         continue;
 191                 back(c);
 192                 if (c == '\n')
 193                         return 1;
 194                 if (!stop && (c == ' ' || c == '\t'))
 195                         return 0;
 196                 charnext(cs, next, back);
 197                 if (stop && !strcmp(stop, cs))
 198                         return 0;
 199                 charnext_str(cs2, cs);
 200                 sbuf_append(sbuf, cs2);
 201         }
 202         return 1;
 203 }
 204
 205 /* evaluate .if strcmp (i.e. 'str'str') */
 206 static int if_strcmp(int (*next)(void), void (*back)(int))
 207 {
 208         char delim[GNLEN];
 209         struct sbuf s1, s2;
 210         int ret;
 211         charnext(delim, next, back);
 212         sbuf_init(&s1);
 213         sbuf_init(&s2);
 214         read_until(&s1, delim, next, back);
 215         read_until(&s2, delim, next, back);
 216         cp_reqbeg();
 217         ret = !strcmp(sbuf_buf(&s1), sbuf_buf(&s2));
 218         sbuf_done(&s1);
 219         sbuf_done(&s2);
 220         return ret;
 221 }
 222
 223 /* evaluate .if condition letters */
 224 static int if_cond(int (*next)(void), void (*back)(int))
 225 {
 226         switch (cp_next()) {
 227         case 'o':
 228                 return n_pg % 2;
 229         case 'e':
 230                 return !(n_pg % 2);
 231         case 't':
 232                 return 1;
 233         case 'n':
 234                 return 0;
 235         }
 236         return 0;
 237 }
 238
 239 /* evaluate .if condition */
 240 static int if_eval(int (*next)(void), void (*back)(int))
 241 {
 242         struct sbuf sbuf;
 243         int ret;
 244         sbuf_init(&sbuf);
 245         read_until(&sbuf, NULL, next, back);
 246         ret = eval(sbuf_buf(&sbuf), '\0') > 0;
 247         sbuf_done(&sbuf);
 248         return ret;
 249 }
 250
 251 static int eval_if(int (*next)(void), void (*back)(int))
 252 {
 253         int neg = 0;
 254         int ret;
 255         int c;
 256         do {
 257                 c = next();
 258         } while (c == ' ' || c == '\t');
 259         if (c == '!') {
 260                 neg = 1;
 261                 c = next();
 262         }
 263         back(c);
 264         if (strchr("oetn", c)) {
 265                 ret = if_cond(next, back);
 266         } else if (!isdigit(c) && !strchr("-+*/%<=>&:.|()", c)) {
 267                 ret = if_strcmp(next, back);
 268         } else {
 269                 ret = if_eval(next, back);
 270         }
 271         return ret != neg;
 272 }
 273
 274 static int ie_cond[NIES];       /* .ie condition stack */
 275 static int ie_depth;
 276
 277 static void tr_if(char **args)
 278 {
 279         int c = eval_if(cp_next, cp_back);
 280         if (args[0][1] == 'i' && args[0][2] == 'e')     /* .ie command */
 281                 if (ie_depth < NIES)
 282                         ie_cond[ie_depth++] = c;
 283         cp_blk(!c);
 284 }
 285
 286 static void tr_el(char **args)
 287 {
 288         cp_blk(ie_depth > 0 ? ie_cond[--ie_depth] : 1);
 289 }
 290
 291 static void tr_na(char **args)
 292 {
 293         n_na = 1;
 294 }
 295
 296 static int adjmode(int c, int def)
 297 {
 298         switch (c) {
 299         case 'l':
 300                 return AD_L;
 301         case 'r':
 302                 return AD_R;
 303         case 'c':
 304                 return AD_C;
 305         case 'b':
 306         case 'n':
 307                 return AD_B;
 308         }
 309         return def;
 310 }
 311
 312 static void tr_ad(char **args)
 313 {
 314         char *s = args[1];
 315         n_na = 0;
 316         if (!s)
 317                 return;
 318         if (isdigit(s[0]))
 319                 n_j = atoi(s) & 15;
 320         else
 321                 n_j = s[0] == 'p' ? AD_P | adjmode(s[1], AD_B) : adjmode(s[0], n_j);
 322 }
 323
 324 static void tr_tm(char **args)
 325 {
 326         fprintf(stderr, "%s\n", args[1]);
 327 }
 328
 329 static void tr_so(char **args)
 330 {
 331         if (args[1])
 332                 in_so(args[1]);
 333 }
 334
 335 static void tr_nx(char **args)
 336 {
 337         in_nx(args[1]);
 338 }
 339
 340 static void tr_ex(char **args)
 341 {
 342         in_ex();
 343 }
 344
 345 static void tr_sy(char **args)
 346 {
 347         system(args[1]);
 348 }
 349
 350 static void tr_lt(char **args)
 351 {
 352         int lt = args[1] ? eval_re(args[1], n_lt, 'm') : n_t0;
 353         n_t0 = n_t0;
 354         n_lt = MAX(0, lt);
 355 }
 356
 357 static void tr_pc(char **args)
 358 {
 359         c_pc = args[1] ? args[1][0] : -1;
 360 }
 361
 362 static int tl_next(void)
 363 {
 364         int c = cp_next();
 365         if (c >= 0 && c == c_pc) {
 366                 in_push(num_str(map("%")), NULL);
 367                 c = cp_next();
 368         }
 369         return c;
 370 }
 371
 372 static void tr_tl(char **args)
 373 {
 374         int c;
 375         do {
 376                 c = cp_next();
 377         } while (c >= 0 && (c == ' ' || c == '\t'));
 378         cp_back(c);
 379         ren_tl(tl_next, cp_back);
 380         do {
 381                 c = cp_next();
 382         } while (c >= 0 && c != '\n');
 383 }
 384
 385 static void tr_ec(char **args)
 386 {
 387         c_ec = args[1] ? args[1][0] : '\\';
 388 }
 389
 390 static void tr_cc(char **args)
 391 {
 392         c_cc = args[1] ? args[1][0] : '.';
 393 }
 394
 395 static void tr_c2(char **args)
 396 {
 397         c_c2 = args[1] ? args[1][0] : '\'';
 398 }
 399
 400 static void tr_eo(char **args)
 401 {
 402         c_ec = -1;
 403 }
 404
 405 static void tr_hc(char **args)
 406 {
 407         char *s = args[1];
 408         if (!s || charread(&s, c_hc) < 0)
 409                 strcpy(c_hc, "\\%");
 410 }
 411
 412 static void tr_nh(char **args)
 413 {
 414         n_hy = 0;
 415 }
 416
 417 static void tr_hy(char **args)
 418 {
 419         n_hy = args[1] ? atoi(args[1]) : 1;
 420 }
 421
 422 static void tr_hyp(char **args)
 423 {
 424         n_hyp = args[1] ? atoi(args[1]) : 1;
 425 }
 426
 427 static void tr_pmll(char **args)
 428 {
 429         n_pmll = args[1] ? atoi(args[1]) : 0;
 430 }
 431
 432 static void tr_lg(char **args)
 433 {
 434         if (args[1])
 435                 n_lg = atoi(args[1]);
 436 }
 437
 438 static void tr_kn(char **args)
 439 {
 440         if (args[1])
 441                 n_kn = atoi(args[1]);
 442 }
 443
 444 static void tr_cp(char **args)
 445 {
 446         if (args[1])
 447                 n_cp = atoi(args[1]);
 448 }
 449
 450 static void tr_ss(char **args)
 451 {
 452         if (args[1]) {
 453                 n_ss = eval_re(args[1], n_ss, 0);
 454                 n_sss = args[2] ? eval_re(args[2], n_sss, 0) : n_ss;
 455         }
 456 }
 457
 458 static void tr_ssh(char **args)
 459 {
 460         n_ssh = args[1] ? eval_re(args[1], n_ssh, 0) : 0;
 461 }
 462
 463 static void tr_cs(char **args)
 464 {
 465         struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL;
 466         if (fn)
 467                 font_setcs(fn, args[2] ? eval(args[2], 0) : 0,
 468                                 args[3] ? eval(args[3], 0) : 0);
 469 }
 470
 471 static void tr_fzoom(char **args)
 472 {
 473         struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL;
 474         if (fn)
 475                 font_setzoom(fn, args[2] ? eval(args[2], 0) : 0);
 476 }
 477
 478 static void tr_ff(char **args)
 479 {
 480         struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL;
 481         int i;
 482         for (i = 2; i <= NARGS; i++)
 483                 if (fn && args[i] && args[i][0] && args[i][1])
 484                         font_feat(fn, args[i] + 1, args[i][0] == '+');
 485 }
 486
 487 static void tr_nm(char **args)
 488 {
 489         if (!args[1]) {
 490                 n_nm = 0;
 491                 return;
 492         }
 493         n_nm = 1;
 494         n_ln = eval_re(args[1], n_ln, 0);
 495         n_ln = MAX(0, n_ln);
 496         if (args[2] && isdigit(args[2][0]))
 497                 n_nM = MAX(1, eval(args[2], 0));
 498         if (args[3] && isdigit(args[3][0]))
 499                 n_nS = MAX(0, eval(args[3], 0));
 500         if (args[4] && isdigit(args[4][0]))
 501                 n_nI = MAX(0, eval(args[4], 0));
 502 }
 503
 504 static void tr_nn(char **args)
 505 {
 506         n_nn = args[1] ? eval(args[1], 0) : 1;
 507 }
 508
 509 static void tr_bd(char **args)
 510 {
 511         if (!args[1] || !strcmp("S", args[1]))
 512                 return;
 513         font_setbd(dev_font(dev_pos(args[1])), args[2] ? eval(args[2], 'u') : 0);
 514 }
 515
 516 static void tr_it(char **args)
 517 {
 518         if (args[2]) {
 519                 n_it = map(args[2]);
 520                 n_itn = eval(args[1], 0);
 521         } else {
 522                 n_it = 0;
 523         }
 524 }
 525
 526 static void tr_mc(char **args)
 527 {
 528         char *s = args[1];
 529         if (s && charread(&s, c_mc) >= 0) {
 530                 n_mc = 1;
 531                 n_mcn = args[2] ? eval(args[2], 'm') : SC_EM;
 532         } else {
 533                 n_mc = 0;
 534         }
 535 }
 536
 537 static void tr_tc(char **args)
 538 {
 539         char *s = args[1];
 540         if (!s || charread(&s, c_tc) < 0)
 541                 strcpy(c_tc, "");
 542 }
 543
 544 static void tr_lc(char **args)
 545 {
 546         char *s = args[1];
 547         if (!s || charread(&s, c_lc) < 0)
 548                 strcpy(c_lc, "");
 549 }
 550
 551 static void tr_lf(char **args)
 552 {
 553         if (args[1])
 554                 in_lf(args[2], eval(args[1], 0));
 555 }
 556
 557 static void tr_chop(char **args)
 558 {
 559         struct sbuf sbuf;
 560         int id;
 561         if (args[1])
 562                 in_lf(args[2], eval(args[1], 0));
 563         id = map(args[1]);
 564         if (str_get(id)) {
 565                 sbuf_init(&sbuf);
 566                 sbuf_append(&sbuf, str_get(id));
 567                 if (!sbuf_empty(&sbuf)) {
 568                         sbuf_cut(&sbuf, sbuf_len(&sbuf) - 1);
 569                         str_set(id, sbuf_buf(&sbuf));
 570                 }
 571                 sbuf_done(&sbuf);
 572         }
 573 }
 574
 575 /* character translation (.tr) */
 576 static struct dict cmap;                /* character mapping */
 577 static char cmap_src[NCMAPS][GNLEN];    /* source character */
 578 static char cmap_dst[NCMAPS][GNLEN];    /* character mapping */
 579 static int cmap_n;                      /* number of translated character */
 580
 581 void cmap_add(char *c1, char *c2)
 582 {
 583         int i = dict_get(&cmap, c1);
 584         if (i >= 0) {
 585                 strcpy(cmap_dst[i], c2);
 586         } else if (cmap_n < NCMAPS) {
 587                 strcpy(cmap_src[cmap_n], c1);
 588                 strcpy(cmap_dst[cmap_n], c2);
 589                 dict_put(&cmap, cmap_src[cmap_n], cmap_n);
 590                 cmap_n++;
 591         }
 592 }
 593
 594 char *cmap_map(char *c)
 595 {
 596         int i = dict_get(&cmap, c);
 597         return i >= 0 ? cmap_dst[i] : c;
 598 }
 599
 600 static void tr_tr(char **args)
 601 {
 602         char *s = args[1];
 603         char c1[GNLEN], c2[GNLEN];
 604         while (s && charread(&s, c1) >= 0) {
 605                 if (charread(&s, c2) < 0)
 606                         strcpy(c2, " ");
 607                 cmap_add(c1, c2);
 608         }
 609 }
 610
 611 /* character definition (.char) */
 612 static char cdef_src[NCDEFS][GNLEN];    /* source character */
 613 static char *cdef_dst[NCDEFS];          /* character definition */
 614 static int cdef_fn[NCDEFS];             /* owning font */
 615 static int cdef_n;                      /* number of defined characters */
 616 static int cdef_expanding;              /* inside cdef_expand() call */
 617
 618 static int cdef_find(char *c, int fn)
 619 {
 620         int i;
 621         for (i = 0; i < cdef_n; i++)
 622                 if ((!cdef_fn[i] || cdef_fn[i] == fn) && !strcmp(cdef_src[i], c))
 623                         return i;
 624         return -1;
 625 }
 626
 627 /* return the definition of the given character */
 628 char *cdef_map(char *c, int fn)
 629 {
 630         int i = cdef_find(c, fn);
 631         return !cdef_expanding && i >= 0 ? cdef_dst[i] : NULL;
 632 }
 633
 634 int cdef_expand(struct wb *wb, char *s, int fn)
 635 {
 636         char *d = cdef_map(s, fn);
 637         if (!d)
 638                 return 1;
 639         cdef_expanding = 1;
 640         ren_parse(wb, d);
 641         cdef_expanding = 0;
 642         return 0;
 643 }
 644
 645 static void cdef_add(char *fn, char *cs, char *def)
 646 {
 647         char c[GNLEN];
 648         int i;
 649         if (!def || charread(&cs, c) < 0)
 650                 return;
 651         i = cdef_find(c, -1);
 652         if (i < 0 && cdef_n < NCDEFS)
 653                 i = cdef_n++;
 654         if (i >= 0) {
 655                 strncpy(cdef_src[i], c, sizeof(cdef_src[i]) - 1);
 656                 cdef_dst[i] = xmalloc(strlen(def) + 1);
 657                 strcpy(cdef_dst[i], def);
 658                 cdef_fn[i] = fn ? dev_pos(fn) : 0;
 659         }
 660 }
 661
 662 static void cdef_remove(char *cs)
 663 {
 664         char c[GNLEN];
 665         int i;
 666         if (!cs || charread(&cs, c) < 0)
 667                 return;
 668         for (i = 0; i < cdef_n; i++) {
 669                 if (!strcmp(cdef_src[i], c)) {
 670                         free(cdef_dst[i]);
 671                         cdef_dst[i] = NULL;
 672                         cdef_src[i][0] = '\0';
 673                 }
 674         }
 675 }
 676
 677 static void tr_char(char **args)
 678 {
 679         cdef_add(NULL, args[1], args[2]);
 680 }
 681
 682 static void tr_rchar(char **args)
 683 {
 684         int i;
 685         for (i = 1; i <= NARGS; i++)
 686                 if (args[i])
 687                         cdef_remove(args[i]);
 688 }
 689
 690 static void tr_ochar(char **args)
 691 {
 692         cdef_add(args[1], args[2], args[3]);
 693 }
 694
 695 static void tr_fmap(char **args)
 696 {
 697         struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL;
 698         if (fn && args[2])
 699                 font_map(fn, args[2], args[3]);
 700 }
 701
 702 static void arg_regname(struct sbuf *sbuf)
 703 {
 704         char reg[NMLEN];
 705         read_regname(reg);
 706         sbuf_append(sbuf, reg);
 707         sbuf_add(sbuf, 0);
 708 }
 709
 710 static void arg_string(struct sbuf *sbuf)
 711 {
 712         int c;
 713         while ((c = cp_next()) == ' ')
 714                 ;
 715         if (c == '"')
 716                 c = cp_next();
 717         while (c > 0 && c != '\n') {
 718                 if (c != c_ni)
 719                         sbuf_add(sbuf, c);
 720                 c = cp_next();
 721         }
 722         sbuf_add(sbuf, 0);
 723         if (c >= 0)
 724                 cp_back(c);
 725 }
 726
 727 static int mkargs_arg(struct sbuf *sbuf, int (*next)(void), void (*back)(int))
 728 {
 729         int quoted = 0;
 730         int c;
 731         c = next();
 732         while (c == ' ')
 733                 c = next();
 734         if (c == '\n')
 735                 back(c);
 736         if (c < 0 || c == '\n')
 737                 return 1;
 738         if (c == '"') {
 739                 quoted = 1;
 740                 c = next();
 741         }
 742         while (c >= 0 && c != '\n') {
 743                 if (!quoted && c == ' ')
 744                         break;
 745                 if (quoted && c == '"') {
 746                         c = next();
 747                         if (c != '"')
 748                                 break;
 749                 }
 750                 if (c == c_ec) {
 751                         sbuf_add(sbuf, c);
 752                         c = next();
 753                 }
 754                 sbuf_add(sbuf, c);
 755                 c = next();
 756         }
 757         sbuf_add(sbuf, 0);
 758         if (c >= 0)
 759                 back(c);
 760         return 0;
 761 }
 762
 763 /* read macro arguments */
 764 int tr_readargs(char **args, struct sbuf *sbuf, int (*next)(void), void (*back)(int))
 765 {
 766         int idx[NARGS];
 767         int i, n = 0;
 768         while (n < NARGS) {
 769                 idx[n] = sbuf_len(sbuf);
 770                 if (mkargs_arg(sbuf, next, back))
 771                         break;
 772                 n++;
 773         }
 774         for (i = 0; i < n; i++)
 775                 args[i] = sbuf_buf(sbuf) + idx[i];
 776         return n;
 777 }
 778
 779 /* read macro arguments; trims tabs if rmtabs is nonzero */
 780 static int mkargs(char **args, struct sbuf *sbuf)
 781 {
 782         int n = tr_readargs(args, sbuf, cp_next, cp_back);
 783         jmp_eol();
 784         return n;
 785 }
 786
 787 /* read request arguments; trims tabs too */
 788 static int mkargs_req(char **args, struct sbuf *sbuf)
 789 {
 790         int idx[NARGS];
 791         int i, n = 0;
 792         int c;
 793         c = cp_next();
 794         while (n < NARGS) {
 795                 idx[n] = sbuf_len(sbuf);
 796                 while (c == ' ' || c == '\t')
 797                         c = cp_next();
 798                 while (c >= 0 && c != '\n' && c != ' ' && c != '\t') {
 799                         if (c != c_ni)
 800                                 sbuf_add(sbuf, c);
 801                         c = cp_next();
 802                 }
 803                 if (sbuf_len(sbuf) > idx[n])
 804                         n++;
 805                 sbuf_add(sbuf, 0);
 806                 if (c == '\n')
 807                         cp_back(c);
 808                 if (c < 0 || c == '\n')
 809                         break;
 810         }
 811         for (i = 0; i < n; i++)
 812                 args[i] = sbuf_buf(sbuf) + idx[i];
 813         jmp_eol();
 814         return n;
 815 }
 816
 817 /* read arguments for .ds */
 818 static int mkargs_ds(char **args, struct sbuf *sbuf)
 819 {
 820         int idx[NARGS];
 821         int i, n = 0;
 822         idx[n++] = sbuf_len(sbuf);
 823         arg_regname(sbuf);
 824         idx[n++] = sbuf_len(sbuf);
 825         cp_copymode(1);
 826         arg_string(sbuf);
 827         cp_copymode(0);
 828         jmp_eol();
 829         for (i = 0; i < n; i++)
 830                 args[i] = sbuf_buf(sbuf) + idx[i];
 831         return n;
 832 }
 833
 834 /* read arguments for commands .nr that expect a register name */
 835 static int mkargs_reg1(char **args, struct sbuf *sbuf)
 836 {
 837         int n;
 838         int idx0 = sbuf_len(sbuf);
 839         arg_regname(sbuf);
 840         n = mkargs_req(args + 1, sbuf) + 1;
 841         args[0] = sbuf_buf(sbuf) + idx0;
 842         return n;
 843 }
 844
 845 /* do not read arguments; for .if, .ie and .el */
 846 static int mkargs_null(char **args, struct sbuf *sbuf)
 847 {
 848         return 0;
 849 }
 850
 851 /* read the whole line for .tm */
 852 static int mkargs_eol(char **args, struct sbuf *sbuf)
 853 {
 854         int idx0 = sbuf_len(sbuf);
 855         int c;
 856         cp_copymode(1);
 857         c = cp_next();
 858         while (c == ' ')
 859                 c = cp_next();
 860         while (c >= 0 && c != '\n') {
 861                 if (c != c_ni)
 862                         sbuf_add(sbuf, c);
 863                 c = cp_next();
 864         }
 865         cp_copymode(0);
 866         args[0] = sbuf_buf(sbuf) + idx0;
 867         return 1;
 868 }
 869
 870 static struct cmd {
 871         char *id;
 872         void (*f)(char **args);
 873         int (*args)(char **args, struct sbuf *sbuf);
 874 } cmds[] = {
 875         {TR_DIVBEG, tr_divbeg},
 876         {TR_DIVEND, tr_divend},
 877         {TR_DIVVS, tr_divvs},
 878         {TR_POPREN, tr_popren},
 879         {"ab", tr_ab, mkargs_eol},
 880         {"ad", tr_ad},
 881         {"af", tr_af},
 882         {"am", tr_de, mkargs_reg1},
 883         {"as", tr_as, mkargs_ds},
 884         {"bd", tr_bd},
 885         {"bp", tr_bp},
 886         {"br", tr_br},
 887         {"c2", tr_c2},
 888         {"cc", tr_cc},
 889         {"ochar", tr_ochar},
 890         {"ce", tr_ce},
 891         {"ch", tr_ch},
 892         {"char", tr_char, mkargs_ds},
 893         {"chop", tr_chop, mkargs_reg1},
 894         {"cl", tr_cl},
 895         {"cp", tr_cp},
 896         {"cs", tr_cs},
 897         {"da", tr_di},
 898         {"de", tr_de, mkargs_reg1},
 899         {"di", tr_di},
 900         {"ds", tr_ds, mkargs_ds},
 901         {"dt", tr_dt},
 902         {"ec", tr_ec},
 903         {"el", tr_el, mkargs_null},
 904         {"em", tr_em},
 905         {"eo", tr_eo},
 906         {"ev", tr_ev},
 907         {"ex", tr_ex},
 908         {"fc", tr_fc},
 909         {"ff", tr_ff},
 910         {"fi", tr_fi},
 911         {"fl", tr_br},
 912         {"fmap", tr_fmap},
 913         {"fp", tr_fp},
 914         {"fspecial", tr_fspecial},
 915         {"ft", tr_ft},
 916         {"fzoom", tr_fzoom},
 917         {"hc", tr_hc},
 918         {"hcode", tr_hcode},
 919         {"hpf", tr_hpf},
 920         {"hpfa", tr_hpfa},
 921         {"hy", tr_hy},
 922         {"hyp", tr_hyp},
 923         {"hw", tr_hw},
 924         {"ie", tr_if, mkargs_null},
 925         {"if", tr_if, mkargs_null},
 926         {"ig", tr_ig},
 927         {"in", tr_in},
 928         {"it", tr_it},
 929         {"kn", tr_kn},
 930         {"lc", tr_lc},
 931         {"lf", tr_lf},
 932         {"lg", tr_lg},
 933         {"ll", tr_ll},
 934         {"ls", tr_ls},
 935         {"lt", tr_lt},
 936         {"mc", tr_mc},
 937         {"mk", tr_mk},
 938         {"na", tr_na},
 939         {"ne", tr_ne},
 940         {"nf", tr_nf},
 941         {"nh", tr_nh},
 942         {"nm", tr_nm},
 943         {"nn", tr_nn},
 944         {"nr", tr_nr, mkargs_reg1},
 945         {"ns", tr_ns},
 946         {"nx", tr_nx},
 947         {"os", tr_os},
 948         {"pc", tr_pc},
 949         {"pl", tr_pl},
 950         {"pmll", tr_pmll},
 951         {"pn", tr_pn},
 952         {"po", tr_po},
 953         {"ps", tr_ps},
 954         {"rchar", tr_rchar, mkargs_ds},
 955         {"rm", tr_rm},
 956         {"rn", tr_rn},
 957         {"rr", tr_rr},
 958         {"rs", tr_rs},
 959         {"rt", tr_rt},
 960         {"so", tr_so},
 961         {"sp", tr_sp},
 962         {"ss", tr_ss},
 963         {"ssh", tr_ssh},
 964         {"sv", tr_sv},
 965         {"sy", tr_sy, mkargs_eol},
 966         {"ta", tr_ta},
 967         {"tc", tr_tc},
 968         {"ti", tr_ti},
 969         {"tl", tr_tl, mkargs_null},
 970         {"tm", tr_tm, mkargs_eol},
 971         {"tr", tr_tr, mkargs_eol},
 972         {"vs", tr_vs},
 973         {"wh", tr_wh},
 974 };
 975
 976 /* read the next troff request; return zero if a request was executed. */
 977 int tr_nextreq(void)
 978 {
 979         char *args[NARGS + 3] = {NULL};
 980         char cmd[RNLEN + 1];
 981         struct cmd *req;
 982         struct sbuf sbuf;
 983         int c;
 984         if (!tr_nl)
 985                 return 1;
 986         c = cp_next();
 987         if (c == c_ec) {
 988                 int c2 = cp_next();
 989                 if (c2 == '!') {
 990                         args[0] = "\\!";
 991                         sbuf_init(&sbuf);
 992                         cp_copymode(1);
 993                         mkargs_eol(args + 1, &sbuf);
 994                         cp_copymode(0);
 995                         tr_transparent(args);
 996                         sbuf_done(&sbuf);
 997                         return 0;
 998                 }
 999                 cp_back(c2);
1000         }
1001         if (c < 0 || (c != c_cc && c != c_c2)) {
1002                 cp_back(c);
1003                 return 1;
1004         }
1005         memset(args, 0, sizeof(args));
1006         args[0] = cmd;
1007         cmd[0] = c;
1008         req = NULL;
1009         cp_reqbeg();
1010         read_regname(cmd + 1);
1011         sbuf_init(&sbuf);
1012         req = str_dget(map(cmd + 1));
1013         if (req) {
1014                 if (req->args)
1015                         req->args(args + 1, &sbuf);
1016                 else
1017                         mkargs_req(args + 1, &sbuf);
1018                 req->f(args);
1019         } else {
1020                 cp_copymode(1);
1021                 mkargs(args + 1, &sbuf);
1022                 cp_copymode(0);
1023                 if (str_get(map(cmd + 1)))
1024                         in_push(str_get(map(cmd + 1)), args + 1);
1025         }
1026         sbuf_done(&sbuf);
1027         return 0;
1028 }
1029
1030 int tr_next(void)
1031 {
1032         int c;
1033         while (!tr_nextreq())
1034                 ;
1035         c = cp_next();
1036         tr_nl = c == '\n' || c < 0;
1037         return c;
1038 }
1039
1040 void tr_init(void)
1041 {
1042         int i;
1043         for (i = 0; i < LEN(cmds); i++)
1044                 str_dset(map(cmds[i].id), &cmds[i]);
1045         dict_init(&cmap, NCMAPS, -1, 0, 0);
1046 }