sys/src/cmd/htmlroff/t7.c

   1 /*
   2  * 7.  Macros, strings, diversion, and position traps.
   3  *
   4  *      macros can override builtins
   5  *      builtins can be renamed or removed!
   6  */
   7
   8 #include "a.h"
   9
  10 enum
  11 {
  12         MAXARG = 10,
  13         MAXMSTACK = 40
  14 };
  15
  16 /* macro invocation frame */
  17 typedef struct Mac Mac;
  18 struct Mac
  19 {
  20         int argc;
  21         Rune *argv[MAXARG];
  22 };
  23
  24 Mac             mstack[MAXMSTACK];
  25 int             nmstack;
  26 void            emitdi(void);
  27 void            flushdi(void);
  28
  29 /*
  30  * Run a user-defined macro.
  31  */
  32 void popmacro(void);
  33 int
  34 runmacro(int dot, int argc, Rune **argv)
  35 {
  36         Rune *p;
  37         int i;
  38         Mac *m;
  39
  40 if(verbose && isupperrune(argv[0][0])) fprint(2, "run: %S\n", argv[0]);
  41         p = getds(argv[0]);
  42         if(p == nil){
  43                 if(verbose)
  44                         warn("ignoring unknown request %C%S", dot, argv[0]);
  45                 if(verbose > 1){
  46                         for(i=0; i<argc; i++)
  47                                 fprint(2, " %S", argv[i]);
  48                         fprint(2, "\n");
  49                 }
  50                 return -1;
  51         }
  52         if(nmstack >= nelem(mstack)){
  53                 fprint(2, "%L: macro stack overflow:");
  54                 for(i=0; i<nmstack; i++)
  55                         fprint(2, " %S", mstack[i].argv[0]);
  56                 fprint(2, "\n");
  57                 return -1;
  58         }
  59         m = &mstack[nmstack++];
  60         m->argc = argc;
  61         for(i=0; i<argc; i++)
  62                 m->argv[i] = erunestrdup(argv[i]);
  63         pushinputstring(p);
  64         nr(L(".$"), argc-1);
  65         inputnotify(popmacro);
  66         return 0;
  67 }
  68
  69 void
  70 popmacro(void)
  71 {
  72         int i;
  73         Mac *m;
  74
  75         if(--nmstack < 0){
  76                 fprint(2, "%L: macro stack underflow\n");
  77                 return;
  78         }
  79         m = &mstack[nmstack];
  80         for(i=0; i<m->argc; i++)
  81                 free(m->argv[i]);
  82         if(nmstack > 0)
  83                 nr(L(".$"), mstack[nmstack-1].argc-1);
  84         else
  85                 nr(L(".$"), 0);
  86 }
  87
  88 void popmacro1(void);
  89 jmp_buf runjb[10];
  90 int nrunjb;
  91
  92 void
  93 runmacro1(Rune *name)
  94 {
  95         Rune *argv[2];
  96         int obol;
  97
  98 if(verbose) fprint(2, "outcb %p\n", outcb);
  99         obol = bol;
 100         argv[0] = name;
 101         argv[1] = nil;
 102         bol = 1;
 103         if(runmacro('.', 1, argv) >= 0){
 104                 inputnotify(popmacro1);
 105                 if(!setjmp(runjb[nrunjb++]))
 106                         runinput();
 107                 else
 108                         if(verbose) fprint(2, "finished %S\n", name);
 109         }
 110         bol = obol;
 111 }
 112
 113 void
 114 popmacro1(void)
 115 {
 116         popmacro();
 117         if(nrunjb >= 0)
 118                 longjmp(runjb[--nrunjb], 1);
 119 }
 120
 121 /*
 122  * macro arguments
 123  *
 124  *      "" means " inside " "
 125  *      "" empty string
 126  *      \newline can be done
 127  *      argument separator is space (not tab)
 128  *      number register .$ = number of arguments
 129  *      no arguments outside macros or in strings
 130  *
 131  *      arguments copied in copy mode
 132  */
 133
 134 /*
 135  * diversions
 136  *
 137  *      processed output diverted
 138  *      dn dl registers vertical and horizontal size of last diversion
 139  *      .z - current diversion name
 140  */
 141
 142 /*
 143  * traps
 144  *
 145  *      skip most
 146  *      .t register - distance to next trap
 147  */
 148 static Rune *trap0;
 149
 150 void
 151 outtrap(void)
 152 {
 153         Rune *t;
 154
 155         if(outcb)
 156                 return;
 157         if(trap0){
 158 if(verbose) fprint(2, "trap: %S\n", trap0);
 159                 t = trap0;
 160                 trap0 = nil;
 161                 runmacro1(t);
 162                 free(t);
 163         }
 164 }
 165
 166 /* .wh - install trap */
 167 void
 168 r_wh(int argc, Rune **argv)
 169 {
 170         int i;
 171
 172         if(argc < 2)
 173                 return;
 174
 175         i = eval(argv[1]);
 176         if(argc == 2){
 177                 if(i == 0){
 178                         free(trap0);
 179                         trap0 = nil;
 180                 }else
 181                         if(verbose)
 182                                 warn("not removing trap at %d", i);
 183         }
 184         if(argc > 2){
 185                 if(i == 0){
 186                         free(trap0);
 187                         trap0 = erunestrdup(argv[2]);
 188                 }else
 189                         if(verbose)
 190                                 warn("not installing %S trap at %d", argv[2], i);
 191         }
 192 }
 193
 194 void
 195 r_ch(int argc, Rune **argv)
 196 {
 197         int i;
 198
 199         if(argc == 2){
 200                 if(trap0 && runestrcmp(argv[1], trap0) == 0){
 201                         free(trap0);
 202                         trap0 = nil;
 203                 }else
 204                         if(verbose)
 205                                 warn("not removing %S trap", argv[1]);
 206                 return;
 207         }
 208         if(argc >= 3){
 209                 i = eval(argv[2]);
 210                 if(i == 0){
 211                         free(trap0);
 212                         trap0 = erunestrdup(argv[1]);
 213                 }else
 214                         if(verbose)
 215                                 warn("not moving %S trap to %d", argv[1], i);
 216         }
 217 }
 218
 219 void
 220 r_dt(int argc, Rune **argv)
 221 {
 222         USED(argc);
 223         USED(argv);
 224         warn("ignoring diversion trap");
 225 }
 226
 227 /* define macro - .de, .am, .ig */
 228 void
 229 r_de(int argc, Rune **argv)
 230 {
 231         Rune *end, *p;
 232         Fmt fmt;
 233         int ignore, len;
 234
 235         delreq(argv[1]);
 236         delraw(argv[1]);
 237         ignore = runestrcmp(argv[0], L("ig")) == 0;
 238         if(!ignore)
 239                 runefmtstrinit(&fmt);
 240         end = L("..");
 241         if(argc >= 3)
 242                 end = argv[2];
 243         if(runestrcmp(argv[0], L("am")) == 0 && (p=getds(argv[1])) != nil)
 244                 fmtrunestrcpy(&fmt, p);
 245         len = runestrlen(end);
 246         while((p = readline(CopyMode)) != nil){
 247                 if(runestrncmp(p, end, len) == 0
 248                 && (p[len]==' ' || p[len]==0 || p[len]=='\t'
 249                         || (p[len]=='\\' && p[len+1]=='}'))){
 250                         free(p);
 251                         goto done;
 252                 }
 253                 if(!ignore)
 254                         fmtprint(&fmt, "%S\n", p);
 255                 free(p);
 256         }
 257         warn("eof in %C%S %S - looking for %#Q", dot, argv[0], argv[1], end);
 258 done:
 259         if(ignore)
 260                 return;
 261         p = runefmtstrflush(&fmt);
 262         if(p == nil)
 263                 sysfatal("out of memory");
 264         ds(argv[1], p);
 265         free(p);
 266 }
 267
 268 /* define string .ds .as */
 269 void
 270 r_ds(Rune *cmd)
 271 {
 272         Rune *name, *line, *p;
 273
 274         name = copyarg();
 275         line = readline(CopyMode);
 276         if(name == nil || line == nil){
 277                 free(name);
 278                 return;
 279         }
 280         p = line;
 281         if(*p == '"')
 282                 p++;
 283         if(cmd[0] == 'd')
 284                 ds(name, p);
 285         else
 286                 as(name, p);
 287         free(name);
 288         free(line);
 289 }
 290
 291 /* remove request, macro, or string */
 292 void
 293 r_rm(int argc, Rune **argv)
 294 {
 295         int i;
 296
 297         emitdi();
 298         for(i=1; i<argc; i++){
 299                 delreq(argv[i]);
 300                 delraw(argv[i]);
 301                 ds(argv[i], nil);
 302         }
 303 }
 304
 305 /* .rn - rename request, macro, or string */
 306 void
 307 r_rn(int argc, Rune **argv)
 308 {
 309         USED(argc);
 310         renreq(argv[1], argv[2]);
 311         renraw(argv[1], argv[2]);
 312         ds(argv[2], getds(argv[1]));
 313         ds(argv[1], nil);
 314 }
 315
 316 /* .di - divert output to macro xx */
 317 /* .da - divert, appending to macro */
 318 /* page offsetting is not done! */
 319 Fmt difmt;
 320 int difmtinit;
 321 Rune di[20][100];
 322 int ndi;
 323
 324 void
 325 emitdi(void)
 326 {
 327         flushdi();
 328         runefmtstrinit(&difmt);
 329         difmtinit = 1;
 330         fmtrune(&difmt, Uformatted);
 331 }
 332
 333 void
 334 flushdi(void)
 335 {
 336         int n;
 337         Rune *p;
 338
 339         if(ndi == 0 || difmtinit == 0)
 340                 return;
 341         fmtrune(&difmt, Uunformatted);
 342         p = runefmtstrflush(&difmt);
 343         memset(&difmt, 0, sizeof difmt);
 344         difmtinit = 0;
 345         if(p == nil)
 346                 warn("out of memory in diversion %C%S", dot, di[ndi-1]);
 347         else{
 348                 n = runestrlen(p);
 349                 if(n > 0 && p[n-1] != '\n'){
 350                         p = runerealloc(p, n+2);
 351                         p[n] = '\n';
 352                         p[n+1] = 0;
 353                 }
 354         }
 355         as(di[ndi-1], p);
 356         free(p);
 357 }
 358
 359 void
 360 outdi(Rune r)
 361 {
 362 if(!difmtinit) abort();
 363         if(r == Uempty)
 364                 return;
 365         fmtrune(&difmt, r);
 366 }
 367
 368 /* .di, .da */
 369 void
 370 r_di(int argc, Rune **argv)
 371 {
 372         br();
 373         if(argc > 2)
 374                 warn("extra arguments to %C%S", dot, argv[0]);
 375         if(argc == 1){
 376                 /* end diversion */
 377                 if(ndi <= 0){
 378                         // warn("unmatched %C%S", dot, argv[0]);
 379                         return;
 380                 }
 381                 flushdi();
 382                 if(--ndi == 0){
 383                         _nr(L(".z"), nil);
 384                         outcb = nil;
 385                 }else{
 386                         _nr(L(".z"), di[ndi-1]);
 387                         runefmtstrinit(&difmt);
 388                         fmtrune(&difmt, Uformatted);
 389                         difmtinit = 1;
 390                 }
 391                 return;
 392         }
 393         /* start diversion */
 394         /* various register state should be saved, but it's all useless to us */
 395         flushdi();
 396         if(ndi >= nelem(di))
 397                 sysfatal("%Cdi overflow", dot);
 398         if(argv[0][1] == 'i')
 399                 ds(argv[1], nil);
 400         _nr(L(".z"), argv[1]);
 401         runestrcpy(di[ndi++], argv[1]);
 402         runefmtstrinit(&difmt);
 403         fmtrune(&difmt, Uformatted);
 404         difmtinit = 1;
 405         outcb = outdi;
 406 }
 407
 408 /* .wh - install trap */
 409 /* .ch - change trap */
 410 /* .dt - install diversion trap */
 411
 412 /* set input-line count trap */
 413 int itrapcount;
 414 int itrapwaiting;
 415 Rune *itrapname;
 416
 417 void
 418 r_it(int argc, Rune **argv)
 419 {
 420         if(argc < 3){
 421                 itrapcount = 0;
 422                 return;
 423         }
 424         itrapcount = eval(argv[1]);
 425         free(itrapname);
 426         itrapname = erunestrdup(argv[2]);
 427 }
 428
 429 void
 430 itrap(void)
 431 {
 432         itrapset();
 433         if(itrapwaiting){
 434                 itrapwaiting = 0;
 435                 runmacro1(itrapname);
 436         }
 437 }
 438
 439 void
 440 itrapset(void)
 441 {
 442         if(itrapcount > 0 && --itrapcount == 0)
 443                 itrapwaiting = 1;
 444 }
 445
 446 /* .em - invoke macro when all input is over */
 447 void
 448 r_em(int argc, Rune **argv)
 449 {
 450         Rune buf[20];
 451
 452         USED(argc);
 453         runesnprint(buf, nelem(buf), ".%S\n", argv[1]);
 454         as(L("eof"), buf);
 455 }
 456
 457 int
 458 e_star(void)
 459 {
 460         Rune *p;
 461
 462         p = getds(getname());
 463         if(p)
 464                 pushinputstring(p);
 465         return 0;
 466 }
 467
 468 int
 469 e_t(void)
 470 {
 471         if(inputmode&CopyMode)
 472                 return '\t';
 473         return 0;
 474 }
 475
 476 int
 477 e_a(void)
 478 {
 479         if(inputmode&CopyMode)
 480                 return '\a';
 481         return 0;
 482 }
 483
 484 int
 485 e_backslash(void)
 486 {
 487         if(inputmode&ArgMode)
 488                 ungetrune('\\');
 489         return backslash;
 490 }
 491
 492 int
 493 e_dot(void)
 494 {
 495         return '.';
 496 }
 497
 498 int
 499 e_dollar(void)
 500 {
 501         int c;
 502
 503         c = getnext();
 504         if(c < '1' || c > '9'){
 505                 ungetnext(c);
 506                 return 0;
 507         }
 508         c -= '0';
 509         if(nmstack <= 0 || mstack[nmstack-1].argc <= c)
 510                 return 0;
 511         pushinputstring(mstack[nmstack-1].argv[c]);
 512         return 0;
 513 }
 514
 515 void
 516 t7init(void)
 517 {
 518         addreq(L("de"), r_de, -1);
 519         addreq(L("am"), r_de, -1);
 520         addreq(L("ig"), r_de, -1);
 521         addraw(L("ds"), r_ds);
 522         addraw(L("as"), r_ds);
 523         addreq(L("rm"), r_rm, -1);
 524         addreq(L("rn"), r_rn, -1);
 525         addreq(L("di"), r_di, -1);
 526         addreq(L("da"), r_di, -1);
 527         addreq(L("it"), r_it, -1);
 528         addreq(L("em"), r_em, 1);
 529         addreq(L("wh"), r_wh, -1);
 530         addreq(L("ch"), r_ch, -1);
 531         addreq(L("dt"), r_dt, -1);
 532
 533         addesc('$', e_dollar, CopyMode|ArgMode|HtmlMode);
 534         addesc('*', e_star, CopyMode|ArgMode|HtmlMode);
 535         addesc('t', e_t, CopyMode|ArgMode);
 536         addesc('a', e_a, CopyMode|ArgMode);
 537         addesc('\\', e_backslash, ArgMode|CopyMode);
 538         addesc('.', e_dot, CopyMode|ArgMode);
 539
 540         ds(L("eof"), L(".sp 0.5i\n"));
 541         ds(L(".."), L(""));
 542 }
 543