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
  36 /*
  37  * main.c
  38  * Facility: m4 macro processor
  39  * by: oz
  40  */
  41 #include <sys/cdefs.h>
  42 __FBSDID("$FreeBSD$");
  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 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
 136 #if defined(unix) || defined(__unix__)
 137         { "unix",         SELFTYPE | NOARGS },
 138 #else
 139 #ifdef vms
 140         { "vms",          SELFTYPE | NOARGS },
 141 #endif
 142 #endif
 143 };
 144
 145 #define MAXKEYS (sizeof(keywrds)/sizeof(struct keyblk))
 146
 147 #define MAXRECORD 50
 148 static struct position {
 149         char *name;
 150         unsigned long line;
 151 } quotes[MAXRECORD], paren[MAXRECORD];
 152
 153 static void record(struct position *, int);
 154 static void dump_stack(struct position *, int);
 155
 156 static void macro(void);
 157 static void initkwds(void);
 158 static ndptr inspect(int, char *);
 159 static int do_look_ahead(int, const char *);
 160 static void reallyoutputstr(const char *);
 161 static void reallyputchar(int);
 162
 163 static void enlarge_stack(void);
 164
 165 int main(int, char *[]);
 166
 167 int
 168 main(int argc, char *argv[])
 169 {
 170         int c;
 171         int n;
 172         char *p;
 173
 174         if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 175                 signal(SIGINT, onintr);
 176
 177         init_macros();
 178         initspaces();
 179         STACKMAX = INITSTACKMAX;
 180
 181         mstack = (stae *)xalloc(sizeof(stae) * STACKMAX, NULL);
 182         sstack = (char *)xalloc(STACKMAX, NULL);
 183
 184         maxout = 0;
 185         outfile = NULL;
 186         resizedivs(MAXOUT);
 187
 188         while ((c = getopt(argc, argv, "gst:d:D:U:o:I:P")) != -1)
 189                 switch(c) {
 190
 191                 case 'D':               /* define something..*/
 192                         for (p = optarg; *p; p++)
 193                                 if (*p == '=')
 194                                         break;
 195                         if (*p)
 196                                 *p++ = EOS;
 197                         dodefine(optarg, p);
 198                         break;
 199                 case 'I':
 200                         addtoincludepath(optarg);
 201                         break;
 202                 case 'P':
 203                         prefix_builtins = 1;
 204                         break;
 205                 case 'U':               /* undefine...       */
 206                         macro_popdef(optarg);
 207                         break;
 208                 case 'g':
 209                         mimic_gnu = 1;
 210                         break;
 211                 case 'd':
 212                         set_trace_flags(optarg);
 213                         break;
 214                 case 's':
 215                         synch_lines = 1;
 216                         break;
 217                 case 't':
 218                         mark_traced(optarg, 1);
 219                         break;
 220                 case 'o':
 221                         trace_file(optarg);
 222                         break;
 223                 case '?':
 224                         usage();
 225                 }
 226
 227         argc -= optind;
 228         argv += optind;
 229
 230         initkwds();
 231         if (mimic_gnu)
 232                 setup_builtin("format", FORMATTYPE);
 233
 234         active = stdout;                /* default active output     */
 235         bbase[0] = bufbase;
 236         if (!argc) {
 237                 sp = -1;                /* stack pointer initialized */
 238                 fp = 0;                 /* frame pointer initialized */
 239                 set_input(infile+0, stdin, "stdin");
 240                                         /* default input (naturally) */
 241                 macro();
 242         } else
 243                 for (; argc--; ++argv) {
 244                         p = *argv;
 245                         if (p[0] == '-' && p[1] == EOS)
 246                                 set_input(infile, stdin, "stdin");
 247                         else if (fopen_trypath(infile, p) == NULL)
 248                                 err(1, "%s", p);
 249                         sp = -1;
 250                         fp = 0;
 251                         macro();
 252                         release_input(infile);
 253                 }
 254
 255         if (wrapindex) {
 256                 int i;
 257
 258                 ilevel = 0;             /* in case m4wrap includes.. */
 259                 bufbase = bp = buf;     /* use the entire buffer   */
 260                 if (mimic_gnu) {
 261                         while (wrapindex != 0) {
 262                                 for (i = 0; i < wrapindex; i++)
 263                                         pbstr(m4wraps[i]);
 264                                 wrapindex =0;
 265                                 macro();
 266                         }
 267                 } else {
 268                         for (i = 0; i < wrapindex; i++) {
 269                                 pbstr(m4wraps[i]);
 270                                 macro();
 271                         }
 272                 }
 273         }
 274
 275         if (active != stdout)
 276                 active = stdout;        /* reset output just in case */
 277         for (n = 1; n < maxout; n++)    /* default wrap-up: undivert */
 278                 if (outfile[n] != NULL)
 279                         getdiv(n);
 280                                         /* remove bitbucket if used  */
 281         if (outfile[0] != NULL) {
 282                 (void) fclose(outfile[0]);
 283         }
 284
 285         return 0;
 286 }
 287
 288 /*
 289  * Look ahead for `token'.
 290  * (on input `t == token[0]')
 291  * Used for comment and quoting delimiters.
 292  * Returns 1 if `token' present; copied to output.
 293  *         0 if `token' not found; all characters pushed back
 294  */
 295 static int
 296 do_look_ahead(int t, const char *token)
 297 {
 298         int i;
 299
 300         assert((unsigned char)t == (unsigned char)token[0]);
 301
 302         for (i = 1; *++token; i++) {
 303                 t = gpbc();
 304                 if (t == EOF || (unsigned char)t != (unsigned char)*token) {
 305                         pushback(t);
 306                         while (--i)
 307                                 pushback(*--token);
 308                         return 0;
 309                 }
 310         }
 311         return 1;
 312 }
 313
 314 #define LOOK_AHEAD(t, token) (t != EOF &&               \
 315     (unsigned char)(t)==(unsigned char)(token)[0] &&    \
 316     do_look_ahead(t,token))
 317
 318 /*
 319  * macro - the work horse..
 320  */
 321 static void
 322 macro(void)
 323 {
 324         char token[MAXTOK+1];
 325         int t, l;
 326         ndptr p;
 327         int  nlpar;
 328
 329         cycle {
 330                 t = gpbc();
 331
 332                 if (LOOK_AHEAD(t,lquote)) {     /* strip quotes */
 333                         nlpar = 0;
 334                         record(quotes, nlpar++);
 335                         /*
 336                          * Opening quote: scan forward until matching
 337                          * closing quote has been found.
 338                          */
 339                         do {
 340
 341                                 l = gpbc();
 342                                 if (LOOK_AHEAD(l,rquote)) {
 343                                         if (--nlpar > 0)
 344                                                 outputstr(rquote);
 345                                 } else if (LOOK_AHEAD(l,lquote)) {
 346                                         record(quotes, nlpar++);
 347                                         outputstr(lquote);
 348                                 } else if (l == EOF) {
 349                                         if (nlpar == 1)
 350                                                 warnx("unclosed quote:");
 351                                         else
 352                                                 warnx("%d unclosed quotes:", nlpar);
 353                                         dump_stack(quotes, nlpar);
 354                                         exit(1);
 355                                 } else {
 356                                         if (nlpar > 0) {
 357                                                 if (sp < 0)
 358                                                         reallyputchar(l);
 359                                                 else
 360                                                         CHRSAVE(l);
 361                                         }
 362                                 }
 363                         }
 364                         while (nlpar != 0);
 365                 } else if (sp < 0 && LOOK_AHEAD(t, scommt)) {
 366                         reallyoutputstr(scommt);
 367
 368                         for(;;) {
 369                                 t = gpbc();
 370                                 if (LOOK_AHEAD(t, ecommt)) {
 371                                         reallyoutputstr(ecommt);
 372                                         break;
 373                                 }
 374                                 if (t == EOF)
 375                                         break;
 376                                 reallyputchar(t);
 377                         }
 378                 } else if (t == '_' || isalpha(t)) {
 379                         p = inspect(t, token);
 380                         if (p != NULL)
 381                                 pushback(l = gpbc());
 382                         if (p == NULL || (l != LPAREN &&
 383                             (macro_getdef(p)->type & NEEDARGS) != 0))
 384                                 outputstr(token);
 385                         else {
 386                 /*
 387                  * real thing.. First build a call frame:
 388                  */
 389                                 pushf(fp);      /* previous call frm */
 390                                 pushf(macro_getdef(p)->type); /* type of the call  */
 391                                 pushf(is_traced(p));
 392                                 pushf(0);       /* parenthesis level */
 393                                 fp = sp;        /* new frame pointer */
 394                 /*
 395                  * now push the string arguments:
 396                  */
 397                                 pushs1(macro_getdef(p)->defn);  /* defn string */
 398                                 pushs1((char *)macro_name(p));  /* macro name  */
 399                                 pushs(ep);                      /* start next..*/
 400
 401                                 if (l != LPAREN && PARLEV == 0) {
 402                                     /* no bracks  */
 403                                         chrsave(EOS);
 404
 405                                         if (sp == (int)STACKMAX)
 406                                                 errx(1, "internal stack overflow");
 407                                         eval((const char **) mstack+fp+1, 2,
 408                                             CALTYP, TRACESTATUS);
 409
 410                                         ep = PREVEP;    /* flush strspace */
 411                                         sp = PREVSP;    /* previous sp..  */
 412                                         fp = PREVFP;    /* rewind stack...*/
 413                                 }
 414                         }
 415                 } else if (t == EOF) {
 416                         if (sp > -1 && ilevel <= 0) {
 417                                 warnx( "unexpected end of input, unclosed parenthesis:");
 418                                 dump_stack(paren, PARLEV);
 419                                 exit(1);
 420                         }
 421                         if (ilevel <= 0)
 422                                 break;                  /* all done thanks.. */
 423                         release_input(infile+ilevel--);
 424                         emit_synchline();
 425                         bufbase = bbase[ilevel];
 426                         continue;
 427                 } else if (sp < 0) {            /* not in a macro at all */
 428                         reallyputchar(t);       /* output directly..     */
 429                 }
 430
 431                 else switch(t) {
 432
 433                 case LPAREN:
 434                         if (PARLEV > 0)
 435                                 chrsave(t);
 436                         while (isspace(l = gpbc())) /* skip blank, tab, nl.. */
 437                                 if (PARLEV > 0)
 438                                         chrsave(l);
 439                         pushback(l);
 440                         record(paren, PARLEV++);
 441                         break;
 442
 443                 case RPAREN:
 444                         if (--PARLEV > 0)
 445                                 chrsave(t);
 446                         else {                  /* end of argument list */
 447                                 chrsave(EOS);
 448
 449                                 if (sp == (int)STACKMAX)
 450                                         errx(1, "internal stack overflow");
 451
 452                                 eval((const char **) mstack+fp+1, sp-fp,
 453                                     CALTYP, TRACESTATUS);
 454
 455                                 ep = PREVEP;    /* flush strspace */
 456                                 sp = PREVSP;    /* previous sp..  */
 457                                 fp = PREVFP;    /* rewind stack...*/
 458                         }
 459                         break;
 460
 461                 case COMMA:
 462                         if (PARLEV == 1) {
 463                                 chrsave(EOS);           /* new argument   */
 464                                 while (isspace(l = gpbc()))
 465                                         ;
 466                                 pushback(l);
 467                                 pushs(ep);
 468                         } else
 469                                 chrsave(t);
 470                         break;
 471
 472                 default:
 473                         if (LOOK_AHEAD(t, scommt)) {
 474                                 char *cp;
 475                                 for (cp = scommt; *cp; cp++)
 476                                         chrsave(*cp);
 477                                 for(;;) {
 478                                         t = gpbc();
 479                                         if (LOOK_AHEAD(t, ecommt)) {
 480                                                 for (cp = ecommt; *cp; cp++)
 481                                                         chrsave(*cp);
 482                                                 break;
 483                                         }
 484                                         if (t == EOF)
 485                                             break;
 486                                         CHRSAVE(t);
 487                                 }
 488                         } else
 489                                 CHRSAVE(t);             /* stack the char */
 490                         break;
 491                 }
 492         }
 493 }
 494
 495 /*
 496  * output string directly, without pushing it for reparses.
 497  */
 498 void
 499 outputstr(const char *s)
 500 {
 501         if (sp < 0)
 502                 reallyoutputstr(s);
 503         else
 504                 while (*s)
 505                         CHRSAVE(*s++);
 506 }
 507
 508 void
 509 reallyoutputstr(const char *s)
 510 {
 511         if (synch_lines) {
 512                 while (*s) {
 513                         fputc(*s, active);
 514                         if (*s++ == '\n') {
 515                                 infile[ilevel].synch_lineno++;
 516                                 if (infile[ilevel].synch_lineno !=
 517                                     infile[ilevel].lineno)
 518                                         do_emit_synchline();
 519                         }
 520                 }
 521         } else
 522                 fputs(s, active);
 523 }
 524
 525 void
 526 reallyputchar(int c)
 527 {
 528         putc(c, active);
 529         if (synch_lines && c == '\n') {
 530                 infile[ilevel].synch_lineno++;
 531                 if (infile[ilevel].synch_lineno != infile[ilevel].lineno)
 532                         do_emit_synchline();
 533         }
 534 }
 535
 536 /*
 537  * build an input token..
 538  * consider only those starting with _ or A-Za-z.
 539  */
 540 static ndptr
 541 inspect(int c, char *tp)
 542 {
 543         char *name = tp;
 544         char *etp = tp+MAXTOK;
 545         ndptr p;
 546
 547         *tp++ = c;
 548
 549         while ((isalnum(c = gpbc()) || c == '_') && tp < etp)
 550                 *tp++ = c;
 551         if (c != EOF)
 552                 PUSHBACK(c);
 553         *tp = EOS;
 554         /* token is too long, it won't match anything, but it can still
 555          * be output. */
 556         if (tp == ep) {
 557                 outputstr(name);
 558                 while (isalnum(c = gpbc()) || c == '_') {
 559                         if (sp < 0)
 560                                 reallyputchar(c);
 561                         else
 562                                 CHRSAVE(c);
 563                 }
 564                 *name = EOS;
 565                 return NULL;
 566         }
 567
 568         p = ohash_find(&macros, ohash_qlookupi(&macros, name, (const char **)&tp));
 569         if (p == NULL)
 570                 return NULL;
 571         if (macro_getdef(p) == NULL)
 572                 return NULL;
 573         return p;
 574 }
 575
 576 /*
 577  * initkwds - initialise m4 keywords as fast as possible.
 578  * This very similar to install, but without certain overheads,
 579  * such as calling lookup. Malloc is not used for storing the
 580  * keyword strings, since we simply use the static pointers
 581  * within keywrds block.
 582  */
 583 static void
 584 initkwds(void)
 585 {
 586         unsigned int type;
 587         int i;
 588
 589         for (i = 0; i < (int)MAXKEYS; i++) {
 590                 type = keywrds[i].ktyp & TYPEMASK;
 591                 if ((keywrds[i].ktyp & NOARGS) == 0)
 592                         type |= NEEDARGS;
 593                 setup_builtin(keywrds[i].knam, type);
 594         }
 595 }
 596
 597 static void
 598 record(struct position *t, int lev)
 599 {
 600         if (lev < MAXRECORD) {
 601                 t[lev].name = CURRENT_NAME;
 602                 t[lev].line = CURRENT_LINE;
 603         }
 604 }
 605
 606 static void
 607 dump_stack(struct position *t, int lev)
 608 {
 609         int i;
 610
 611         for (i = 0; i < lev; i++) {
 612                 if (i == MAXRECORD) {
 613                         fprintf(stderr, "   ...\n");
 614                         break;
 615                 }
 616                 fprintf(stderr, "   %s at line %lu\n",
 617                         t[i].name, t[i].line);
 618         }
 619 }
 620
 621
 622 static void
 623 enlarge_stack(void)
 624 {
 625         STACKMAX += STACKMAX/2;
 626         mstack = xrealloc(mstack, sizeof(stae) * STACKMAX,
 627             "Evaluation stack overflow (%lu)",
 628             (unsigned long)STACKMAX);
 629         sstack = xrealloc(sstack, STACKMAX,
 630             "Evaluation stack overflow (%lu)",
 631             (unsigned long)STACKMAX);
 632 }