usr.bin/m4/main.c

   1 /*      $OpenBSD: main.c,v 1.80 2011/09/27 07:24:02 espie Exp $ */
   2 /*      $NetBSD: main.c,v 1.12 1997/02/08 23:54:49 cgd Exp $    */
   3
   4 /*-
   5  * Copyright (c) 1989, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Ozan Yigit at York University.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * $FreeBSD: src/usr.bin/m4/main.c,v 1.33 2012/11/17 01:54:24 svnexp Exp $
  36  */
  37
  38 /*
  39  * main.c
  40  * Facility: m4 macro processor
  41  * by: oz
  42  */
  43
  44 #include <assert.h>
  45 #include <signal.h>
  46 #include <err.h>
  47 #include <errno.h>
  48 #include <unistd.h>
  49 #include <stdio.h>
  50 #include <ctype.h>
  51 #include <string.h>
  52 #include <stddef.h>
  53 #include <stdint.h>
  54 #include <stdlib.h>
  55 #include <ohash.h>
  56 #include "mdef.h"
  57 #include "stdd.h"
  58 #include "extern.h"
  59 #include "pathnames.h"
  60
  61 stae *mstack;                   /* stack of m4 machine */
  62 char *sstack;                   /* shadow stack, for string space extension */
  63 static size_t STACKMAX;         /* current maximum size of stack */
  64 int sp;                         /* current m4 stack pointer */
  65 int fp;                         /* m4 call frame pointer */
  66 struct input_file infile[MAXINP];/* input file stack (0=stdin) */
  67 FILE **outfile;                 /* diversion array(0=bitbucket) */
  68 int maxout;
  69 FILE *active;                   /* active output file pointer */
  70 int ilevel = 0;                 /* input file stack pointer */
  71 int oindex = 0;                 /* diversion index.. */
  72 const char *null = "";          /* as it says.. just a null.. */
  73 char **m4wraps = NULL;          /* m4wraps array. */
  74 int maxwraps = 0;               /* size of m4wraps array */
  75 int wrapindex = 0;              /* current offset in m4wraps */
  76 char lquote[MAXCCHARS + 1] = {LQUOTE};  /* left quote character  (`) */
  77 char rquote[MAXCCHARS + 1] = {RQUOTE};  /* right quote character (') */
  78 char scommt[MAXCCHARS + 1] = {SCOMMT};  /* start character for comment */
  79 char ecommt[MAXCCHARS + 1] = {ECOMMT};  /* end character for comment */
  80 int synch_lines = 0;            /* line synchronisation for C preprocessor */
  81 int prefix_builtins = 0;        /* -P option to prefix builtin keywords */
  82
  83 struct keyblk {
  84         const char      *knam;  /* keyword name */
  85         int             ktyp;   /* keyword type */
  86 };
  87
  88 static struct keyblk keywrds[] = {      /* m4 keywords to be installed */
  89         { "include",    INCLTYPE },
  90         { "sinclude",   SINCTYPE },
  91         { "define",     DEFITYPE },
  92         { "defn",       DEFNTYPE },
  93         { "divert",     DIVRTYPE | NOARGS },
  94         { "expr",       EXPRTYPE },
  95         { "eval",       EXPRTYPE },
  96         { "substr",     SUBSTYPE },
  97         { "ifelse",     IFELTYPE },
  98         { "ifdef",      IFDFTYPE },
  99         { "len",        LENGTYPE },
 100         { "incr",       INCRTYPE },
 101         { "decr",       DECRTYPE },
 102         { "dnl",        DNLNTYPE | NOARGS },
 103         { "changequote",CHNQTYPE | NOARGS },
 104         { "changecom",  CHNCTYPE | NOARGS },
 105         { "index",      INDXTYPE },
 106 #ifdef EXTENDED
 107         { "paste",      PASTTYPE },
 108         { "spaste",     SPASTYPE },
 109         /* Newer extensions, needed to handle gnu-m4 scripts */
 110         { "indir",      INDIRTYPE},
 111         { "builtin",    BUILTINTYPE},
 112         { "patsubst",   PATSTYPE},
 113         { "regexp",     REGEXPTYPE},
 114         { "esyscmd",    ESYSCMDTYPE},
 115         { "__file__",   FILENAMETYPE | NOARGS},
 116         { "__line__",   LINETYPE | NOARGS},
 117 #endif
 118         { "popdef",     POPDTYPE },
 119         { "pushdef",    PUSDTYPE },
 120         { "dumpdef",    DUMPTYPE | NOARGS },
 121         { "shift",      SHIFTYPE | NOARGS },
 122         { "translit",   TRNLTYPE },
 123         { "undefine",   UNDFTYPE },
 124         { "undivert",   UNDVTYPE | NOARGS },
 125         { "divnum",     DIVNTYPE | NOARGS },
 126         { "maketemp",   MKTMTYPE },
 127         { "mkstemp",    MKTMTYPE },
 128         { "errprint",   ERRPTYPE | NOARGS },
 129         { "m4wrap",     M4WRTYPE | NOARGS },
 130         { "m4exit",     EXITTYPE | NOARGS },
 131         { "syscmd",     SYSCTYPE },
 132         { "sysval",     SYSVTYPE | NOARGS },
 133         { "traceon",    TRACEONTYPE | NOARGS },
 134         { "traceoff",   TRACEOFFTYPE | NOARGS },
 135         { "unix",       SELFTYPE | NOARGS },
 136 };
 137
 138 #define MAXKEYS (sizeof(keywrds) / sizeof(struct keyblk))
 139
 140 #define MAXRECORD 50
 141 static struct position {
 142         char *name;
 143         unsigned long line;
 144 } quotes[MAXRECORD], paren[MAXRECORD];
 145
 146 static void record(struct position *, int);
 147 static void dump_stack(struct position *, int);
 148
 149 static void macro(void);
 150 static void initkwds(void);
 151 static ndptr inspect(int, char *);
 152 static int do_look_ahead(int, const char *);
 153 static void reallyoutputstr(const char *);
 154 static void reallyputchar(int);
 155
 156 static void enlarge_stack(void);
 157
 158 int exit_code = 0;
 159
 160 int
 161 main(int argc, char *argv[])
 162 {
 163         int c;
 164         int n;
 165         char *p;
 166
 167         if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 168                 signal(SIGINT, onintr);
 169
 170         init_macros();
 171         initspaces();
 172         STACKMAX = INITSTACKMAX;
 173
 174         mstack = (stae *)xalloc(sizeof(stae) * STACKMAX, NULL);
 175         sstack = (char *)xalloc(STACKMAX, NULL);
 176
 177         maxout = 0;
 178         outfile = NULL;
 179         resizedivs(MAXOUT);
 180
 181         while ((c = getopt(argc, argv, "gst:d:D:U:o:I:P")) != -1)
 182                 switch(c) {
 183
 184                 case 'D':       /* define something.. */
 185                         for (p = optarg; *p; p++) {
 186                                 if (*p == '=')
 187                                         break;
 188                         }
 189                         if (*p)
 190                                 *p++ = EOS;
 191                         dodefine(optarg, p);
 192                         break;
 193                 case 'I':
 194                         addtoincludepath(optarg);
 195                         break;
 196                 case 'P':
 197                         prefix_builtins = 1;
 198                         break;
 199                 case 'U':       /* undefine... */
 200                         macro_popdef(optarg);
 201                         break;
 202                 case 'g':
 203                         mimic_gnu = 1;
 204                         break;
 205                 case 'd':
 206                         set_trace_flags(optarg);
 207                         break;
 208                 case 's':
 209                         synch_lines = 1;
 210                         break;
 211                 case 't':
 212                         mark_traced(optarg, 1);
 213                         break;
 214                 case 'o':
 215                         trace_file(optarg);
 216                         break;
 217                 case '?':
 218                         usage();
 219                 }
 220
 221         argc -= optind;
 222         argv += optind;
 223
 224         initkwds();
 225         if (mimic_gnu)
 226                 setup_builtin("format", FORMATTYPE);
 227
 228         active = stdout;                /* default active output     */
 229         bbase[0] = bufbase;
 230         if (argc == 0) {
 231                 sp = -1;                /* stack pointer initialized */
 232                 fp = 0;                 /* frame pointer initialized */
 233                 set_input(infile + 0, stdin, "stdin");
 234                                         /* default input (naturally) */
 235                 macro();
 236         } else {
 237                 for (; argc--; ++argv) {
 238                         p = *argv;
 239                         if (p[0] == '-' && p[1] == EOS)
 240                                 set_input(infile, stdin, "stdin");
 241                         else if (fopen_trypath(infile, p) == NULL)
 242                                 err(1, "%s", p);
 243                         sp = -1;
 244                         fp = 0;
 245                         macro();
 246                         release_input(infile);
 247                 }
 248         }
 249
 250         if (wrapindex) {
 251                 int i;
 252
 253                 ilevel = 0;             /* in case m4wrap includes.. */
 254                 bufbase = bp = buf;     /* use the entire buffer   */
 255                 if (mimic_gnu) {
 256                         while (wrapindex != 0) {
 257                                 for (i = 0; i < wrapindex; i++)
 258                                         pbstr(m4wraps[i]);
 259                                 wrapindex =0;
 260                                 macro();
 261                         }
 262                 } else {
 263                         for (i = 0; i < wrapindex; i++) {
 264                                 pbstr(m4wraps[i]);
 265                                 macro();
 266                         }
 267                 }
 268         }
 269
 270         if (active != stdout)
 271                 active = stdout;        /* reset output just in case */
 272         for (n = 1; n < maxout; n++) {  /* default wrap-up: undivert */
 273                 if (outfile[n] != NULL)
 274                         getdiv(n);
 275         }
 276         /* remove bitbucket if used */
 277         if (outfile[0] != NULL)
 278                 fclose(outfile[0]);
 279
 280         return exit_code;
 281 }
 282
 283 /*
 284  * Look ahead for `token'.
 285  * (on input `t == token[0]')
 286  * Used for comment and quoting delimiters.
 287  * Returns 1 if `token' present; copied to output.
 288  *         0 if `token' not found; all characters pushed back
 289  */
 290 static int
 291 do_look_ahead(int t, const char *token)
 292 {
 293         int i;
 294
 295         assert((unsigned char)t == (unsigned char)token[0]);
 296
 297         for (i = 1; *++token; i++) {
 298                 t = gpbc();
 299                 if (t == EOF || (unsigned char)t != (unsigned char)*token) {
 300                         pushback(t);
 301                         while (--i)
 302                                 pushback(*--token);
 303                         return 0;
 304                 }
 305         }
 306         return 1;
 307 }
 308
 309 #define LOOK_AHEAD(t, token) (t != EOF &&               \
 310     (unsigned char)(t) == (unsigned char)(token)[0] &&  \
 311     do_look_ahead(t, token))
 312
 313 /*
 314  * macro - the work horse..
 315  */
 316 static void
 317 macro(void)
 318 {
 319         char token[MAXTOK + 1];
 320         int t, l;
 321         ndptr p;
 322         int nlpar;
 323
 324         for (;;) {
 325                 t = gpbc();
 326
 327                 if (LOOK_AHEAD(t, lquote)) {    /* strip quotes */
 328                         nlpar = 0;
 329                         record(quotes, nlpar++);
 330                         /*
 331                          * Opening quote: scan forward until matching
 332                          * closing quote has been found.
 333                          */
 334                         do {
 335                                 l = gpbc();
 336                                 if (LOOK_AHEAD(l,rquote)) {
 337                                         if (--nlpar > 0)
 338                                                 outputstr(rquote);
 339                                 } else if (LOOK_AHEAD(l,lquote)) {
 340                                         record(quotes, nlpar++);
 341                                         outputstr(lquote);
 342                                 } else if (l == EOF) {
 343                                         if (nlpar == 1)
 344                                                 warnx("unclosed quote:");
 345                                         else
 346                                                 warnx("%d unclosed quotes:", nlpar);
 347                                         dump_stack(quotes, nlpar);
 348                                         exit(1);
 349                                 } else {
 350                                         if (nlpar > 0) {
 351                                                 if (sp < 0)
 352                                                         reallyputchar(l);
 353                                                 else
 354                                                         CHRSAVE(l);
 355                                         }
 356                                 }
 357                         }
 358                         while (nlpar != 0);
 359                 } else if (sp < 0 && LOOK_AHEAD(t, scommt)) {
 360                         reallyoutputstr(scommt);
 361
 362                         for(;;) {
 363                                 t = gpbc();
 364                                 if (LOOK_AHEAD(t, ecommt)) {
 365                                         reallyoutputstr(ecommt);
 366                                         break;
 367                                 }
 368                                 if (t == EOF)
 369                                         break;
 370                                 reallyputchar(t);
 371                         }
 372                 } else if (t == '_' || isalpha(t)) {
 373                         p = inspect(t, token);
 374                         if (p != NULL)
 375                                 pushback(l = gpbc());
 376                         if (p == NULL || (l != LPAREN &&
 377                             (macro_getdef(p)->type & NEEDARGS) != 0))
 378                                 outputstr(token);
 379                         else {
 380                                 /*
 381                                  * real thing.. First build a call frame:
 382                                  */
 383                                 pushf(fp);      /* previous call frm */
 384                                 /* type of the call */
 385                                 pushf(macro_getdef(p)->type);
 386                                 pushf(is_traced(p));
 387                                 pushf(0);       /* parenthesis level */
 388                                 fp = sp;        /* new frame pointer */
 389                                 /*
 390                                  * now push the string arguments:
 391                                  */
 392                                 pushs1(macro_getdef(p)->defn);  /* defn string */
 393                                 pushs1((char *)macro_name(p));  /* macro name  */
 394                                 pushs(ep);                      /* start next..*/
 395
 396                                 if (l != LPAREN && PARLEV == 0) {
 397                                         /* no bracks  */
 398                                         chrsave(EOS);
 399
 400                                         if (sp == (int)STACKMAX) {
 401                                                 errx(1,
 402                                                     "internal stack overflow");
 403                                         }
 404                                         eval((const char **) mstack + fp + 1, 2,
 405                                             CALTYP, TRACESTATUS);
 406
 407                                         ep = PREVEP;    /* flush strspace */
 408                                         sp = PREVSP;    /* previous sp..  */
 409                                         fp = PREVFP;    /* rewind stack...*/
 410                                 }
 411                         }
 412                 } else if (t == EOF) {
 413                         if (sp > -1 && ilevel <= 0) {
 414                                 warnx( "unexpected end of input, unclosed parenthesis:");
 415                                 dump_stack(paren, PARLEV);
 416                                 exit(1);
 417                         }
 418                         if (ilevel <= 0)
 419                                 break;                  /* all done thanks.. */
 420                         release_input(infile+ilevel--);
 421                         emit_synchline();
 422                         bufbase = bbase[ilevel];
 423                         continue;
 424                 } else if (sp < 0) {            /* not in a macro at all */
 425                         reallyputchar(t);       /* output directly..     */
 426                 }
 427
 428                 else switch(t) {
 429
 430                 case LPAREN:
 431                         if (PARLEV > 0)
 432                                 chrsave(t);
 433                         while (isspace(l = gpbc())) /* skip blank, tab, nl.. */
 434                                 if (PARLEV > 0)
 435                                         chrsave(l);
 436                         pushback(l);
 437                         record(paren, PARLEV++);
 438                         break;
 439
 440                 case RPAREN:
 441                         if (--PARLEV > 0)
 442                                 chrsave(t);
 443                         else {                  /* end of argument list */
 444                                 chrsave(EOS);
 445
 446                                 if (sp == (int)STACKMAX)
 447                                         errx(1, "internal stack overflow");
 448
 449                                 eval((const char **) mstack + fp + 1, sp-fp,
 450                                     CALTYP, TRACESTATUS);
 451
 452                                 ep = PREVEP;    /* flush strspace */
 453                                 sp = PREVSP;    /* previous sp..  */
 454                                 fp = PREVFP;    /* rewind stack...*/
 455                         }
 456                         break;
 457
 458                 case COMMA:
 459                         if (PARLEV == 1) {
 460                                 chrsave(EOS);           /* new argument   */
 461                                 while (isspace(l = gpbc()))
 462                                         ;
 463                                 pushback(l);
 464                                 pushs(ep);
 465                         } else
 466                                 chrsave(t);
 467                         break;
 468
 469                 default:
 470                         if (LOOK_AHEAD(t, scommt)) {
 471                                 char *cp;
 472                                 for (cp = scommt; *cp; cp++)
 473                                         chrsave(*cp);
 474                                 for(;;) {
 475                                         t = gpbc();
 476                                         if (LOOK_AHEAD(t, ecommt)) {
 477                                                 for (cp = ecommt; *cp; cp++)
 478                                                         chrsave(*cp);
 479                                                 break;
 480                                         }
 481                                         if (t == EOF)
 482                                                 break;
 483                                         CHRSAVE(t);
 484                                 }
 485                         } else
 486                                 CHRSAVE(t);             /* stack the char */
 487                         break;
 488                 }
 489         }
 490 }
 491
 492 /*
 493  * output string directly, without pushing it for reparses.
 494  */
 495 void
 496 outputstr(const char *s)
 497 {
 498         if (sp < 0)
 499                 reallyoutputstr(s);
 500         else
 501                 while (*s)
 502                         CHRSAVE(*s++);
 503 }
 504
 505 void
 506 reallyoutputstr(const char *s)
 507 {
 508         if (synch_lines) {
 509                 while (*s) {
 510                         fputc(*s, active);
 511                         if (*s++ == '\n') {
 512                                 infile[ilevel].synch_lineno++;
 513                                 if (infile[ilevel].synch_lineno !=
 514                                     infile[ilevel].lineno)
 515                                         do_emit_synchline();
 516                         }
 517                 }
 518         } else
 519                 fputs(s, active);
 520 }
 521
 522 void
 523 reallyputchar(int c)
 524 {
 525         putc(c, active);
 526         if (synch_lines && c == '\n') {
 527                 infile[ilevel].synch_lineno++;
 528                 if (infile[ilevel].synch_lineno != infile[ilevel].lineno)
 529                         do_emit_synchline();
 530         }
 531 }
 532
 533 /*
 534  * build an input token..
 535  * consider only those starting with _ or A-Za-z.
 536  */
 537 static ndptr
 538 inspect(int c, char *tp)
 539 {
 540         char *name = tp;
 541         char *etp = tp + MAXTOK;
 542         ndptr p;
 543
 544         *tp++ = c;
 545
 546         while ((isalnum(c = gpbc()) || c == '_') && tp < etp)
 547                 *tp++ = c;
 548         if (c != EOF)
 549                 PUSHBACK(c);
 550         *tp = EOS;
 551         /* token is too long, it won't match anything, but it can still
 552          * be output. */
 553         if (tp == ep) {
 554                 outputstr(name);
 555                 while (isalnum(c = gpbc()) || c == '_') {
 556                         if (sp < 0)
 557                                 reallyputchar(c);
 558                         else
 559                                 CHRSAVE(c);
 560                 }
 561                 *name = EOS;
 562                 return NULL;
 563         }
 564
 565         p = ohash_find(&macros, ohash_qlookupi(&macros, name, (const char **)(void *)&tp));
 566         if (p == NULL)
 567                 return NULL;
 568         if (macro_getdef(p) == NULL)
 569                 return NULL;
 570         return p;
 571 }
 572
 573 /*
 574  * initkwds - initialize m4 keywords as fast as possible.
 575  * This very similar to install, but without certain overheads,
 576  * such as calling lookup. Malloc is not used for storing the
 577  * keyword strings, since we simply use the static pointers
 578  * within keywrds block.
 579  */
 580 static void
 581 initkwds(void)
 582 {
 583         unsigned int type;
 584         int i;
 585
 586         for (i = 0; i < (int)MAXKEYS; i++) {
 587                 type = keywrds[i].ktyp & TYPEMASK;
 588                 if ((keywrds[i].ktyp & NOARGS) == 0)
 589                         type |= NEEDARGS;
 590                 setup_builtin(keywrds[i].knam, type);
 591         }
 592 }
 593
 594 static void
 595 record(struct position *t, int lev)
 596 {
 597         if (lev < MAXRECORD) {
 598                 t[lev].name = CURRENT_NAME;
 599                 t[lev].line = CURRENT_LINE;
 600         }
 601 }
 602
 603 static void
 604 dump_stack(struct position *t, int lev)
 605 {
 606         int i;
 607
 608         for (i = 0; i < lev; i++) {
 609                 if (i == MAXRECORD) {
 610                         fprintf(stderr, "   ...\n");
 611                         break;
 612                 }
 613                 fprintf(stderr, "   %s at line %lu\n",
 614                         t[i].name, t[i].line);
 615         }
 616 }
 617
 618
 619 static void
 620 enlarge_stack(void)
 621 {
 622         STACKMAX += STACKMAX/2;
 623         mstack = xrealloc(mstack, sizeof(stae) * STACKMAX,
 624             "Evaluation stack overflow (%lu)",
 625             (unsigned long)STACKMAX);
 626         sstack = xrealloc(sstack, STACKMAX,
 627             "Evaluation stack overflow (%lu)",
 628             (unsigned long)STACKMAX);
 629 }