usr.bin/m4/gnum4.c

   1 /* $NetBSD: gnum4.c,v 1.9 2012/03/20 20:34:58 matt Exp $ */
   2 /* $OpenBSD: gnum4.c,v 1.39 2008/08/21 21:01:04 espie Exp $ */
   3
   4 /*
   5  * Copyright (c) 1999 Marc Espie
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * functions needed to support gnu-m4 extensions, including a fake freezing
  31  */
  32 #if HAVE_NBTOOL_CONFIG_H
  33 #include "nbtool_config.h"
  34 #endif
  35 #include <sys/cdefs.h>
  36 __RCSID("$NetBSD: gnum4.c,v 1.9 2012/03/20 20:34:58 matt Exp $");
  37
  38 #include <sys/param.h>
  39 #include <sys/types.h>
  40 #include <sys/wait.h>
  41 #include <ctype.h>
  42 #include <err.h>
  43 #include <paths.h>
  44 #include <regex.h>
  45 #include <stddef.h>
  46 #include <stdlib.h>
  47 #include <stdio.h>
  48 #include <string.h>
  49 #include <errno.h>
  50 #include <unistd.h>
  51 #include "mdef.h"
  52 #include "stdd.h"
  53 #include "extern.h"
  54
  55
  56 int mimic_gnu = 0;
  57 #ifndef SIZE_T_MAX
  58 #define SIZE_T_MAX (size_t)~0ull
  59 #endif
  60
  61 /*
  62  * Support for include path search
  63  * First search in the current directory.
  64  * If not found, and the path is not absolute, include path kicks in.
  65  * First, -I options, in the order found on the command line.
  66  * Then M4PATH env variable
  67  */
  68
  69 struct path_entry {
  70         char *name;
  71         struct path_entry *next;
  72 } *first, *last;
  73
  74 static struct path_entry *new_path_entry(const char *);
  75 static void ensure_m4path(void);
  76 static struct input_file *dopath(struct input_file *, const char *);
  77
  78 static struct path_entry *
  79 new_path_entry(const char *dirname)
  80 {
  81         struct path_entry *n;
  82
  83         n = malloc(sizeof(struct path_entry));
  84         if (!n)
  85                 errx(1, "out of memory");
  86         n->name = strdup(dirname);
  87         if (!n->name)
  88                 errx(1, "out of memory");
  89         n->next = 0;
  90         return n;
  91 }
  92
  93 void
  94 addtoincludepath(const char *dirname)
  95 {
  96         struct path_entry *n;
  97
  98         n = new_path_entry(dirname);
  99
 100         if (last) {
 101                 last->next = n;
 102                 last = n;
 103         }
 104         else
 105                 last = first = n;
 106 }
 107
 108 static void
 109 ensure_m4path(void)
 110 {
 111         static int envpathdone = 0;
 112         char *envpath;
 113         char *sweep;
 114         char *path;
 115
 116         if (envpathdone)
 117                 return;
 118         envpathdone = TRUE;
 119         envpath = getenv("M4PATH");
 120         if (!envpath)
 121                 return;
 122         /* for portability: getenv result is read-only */
 123         envpath = strdup(envpath);
 124         if (!envpath)
 125                 errx(1, "out of memory");
 126         for (sweep = envpath;
 127             (path = strsep(&sweep, ":")) != NULL;)
 128             addtoincludepath(path);
 129         free(envpath);
 130 }
 131
 132 static
 133 struct input_file *
 134 dopath(struct input_file *i, const char *filename)
 135 {
 136         char path[MAXPATHLEN];
 137         struct path_entry *pe;
 138         FILE *f;
 139
 140         for (pe = first; pe; pe = pe->next) {
 141                 snprintf(path, sizeof(path), "%s/%s", pe->name, filename);
 142                 if ((f = fopen(path, "r")) != 0) {
 143                         set_input(i, f, path);
 144                         return i;
 145                 }
 146         }
 147         return NULL;
 148 }
 149
 150 struct input_file *
 151 fopen_trypath(struct input_file *i, const char *filename)
 152 {
 153         FILE *f;
 154
 155         f = fopen(filename, "r");
 156         if (f != NULL) {
 157                 set_input(i, f, filename);
 158                 return i;
 159         }
 160         if (filename[0] == '/')
 161                 return NULL;
 162
 163         ensure_m4path();
 164
 165         return dopath(i, filename);
 166 }
 167
 168 void
 169 doindir(const char *argv[], int argc)
 170 {
 171         ndptr n;
 172         struct macro_definition *p;
 173
 174         n = lookup(argv[2]);
 175         if (n == NULL || (p = macro_getdef(n)) == NULL)
 176                 m4errx(1, "indir: undefined macro %s.", argv[2]);
 177         argv[1] = p->defn;
 178
 179         eval(argv+1, argc-1, p->type, is_traced(n));
 180 }
 181
 182 void
 183 dobuiltin(const char *argv[], int argc)
 184 {
 185         ndptr p;
 186
 187         argv[1] = NULL;
 188         p = macro_getbuiltin(argv[2]);
 189         if (p != NULL)
 190                 eval(argv+1, argc-1, macro_builtin_type(p), is_traced(p));
 191         else
 192                 m4errx(1, "unknown builtin %s.", argv[2]);
 193 }
 194
 195
 196 /* We need some temporary buffer space, as pb pushes BACK and substitution
 197  * proceeds forward... */
 198 static char *buffer;
 199 static size_t bufsize = 0;
 200 static size_t current = 0;
 201
 202 static void addchars(const char *, size_t);
 203 static void addchar(int);
 204 static char *twiddle(const char *);
 205 static char *getstring(void);
 206 static void exit_regerror(int, regex_t *) __dead;
 207 static void do_subst(const char *, regex_t *, const char *, regmatch_t *);
 208 static void do_regexpindex(const char *, regex_t *, regmatch_t *);
 209 static void do_regexp(const char *, regex_t *, const char *, regmatch_t *);
 210 static void add_sub(size_t, const char *, regex_t *, regmatch_t *);
 211 static void add_replace(const char *, regex_t *, const char *, regmatch_t *);
 212 #define addconstantstring(s) addchars((s), sizeof(s)-1)
 213
 214 static void
 215 addchars(const char *c, size_t n)
 216 {
 217         if (n == 0)
 218                 return;
 219         while (current + n > bufsize) {
 220                 if (bufsize == 0)
 221                         bufsize = 1024;
 222                 else
 223                         bufsize *= 2;
 224                 buffer = xrealloc(buffer, bufsize, NULL);
 225         }
 226         memcpy(buffer+current, c, n);
 227         current += n;
 228 }
 229
 230 static void
 231 addchar(int c)
 232 {
 233         if (current +1 > bufsize) {
 234                 if (bufsize == 0)
 235                         bufsize = 1024;
 236                 else
 237                         bufsize *= 2;
 238                 buffer = xrealloc(buffer, bufsize, NULL);
 239         }
 240         buffer[current++] = c;
 241 }
 242
 243 static char *
 244 getstring(void)
 245 {
 246         addchar('\0');
 247         current = 0;
 248         return buffer;
 249 }
 250
 251
 252 static void
 253 exit_regerror(int er, regex_t *re)
 254 {
 255         size_t  errlen;
 256         char    *errbuf;
 257
 258         errlen = regerror(er, re, NULL, 0);
 259         errbuf = xalloc(errlen,
 260             "malloc in regerror: %lu", (unsigned long)errlen);
 261         regerror(er, re, errbuf, errlen);
 262         m4errx(1, "regular expression error: %s.", errbuf);
 263 }
 264
 265 static void
 266 add_sub(size_t n, const char *string, regex_t *re, regmatch_t *pm)
 267 {
 268         if (n > re->re_nsub)
 269                 warnx("No subexpression %zu", n);
 270         /* Subexpressions that did not match are
 271          * not an error.  */
 272         else if (pm[n].rm_so != -1 &&
 273             pm[n].rm_eo != -1) {
 274                 addchars(string + pm[n].rm_so,
 275                         pm[n].rm_eo - pm[n].rm_so);
 276         }
 277 }
 278
 279 /* Add replacement string to the output buffer, recognizing special
 280  * constructs and replacing them with substrings of the original string.
 281  */
 282 static void
 283 add_replace(const char *string, regex_t *re, const char *replace, regmatch_t *pm)
 284 {
 285         const char *p;
 286
 287         for (p = replace; *p != '\0'; p++) {
 288                 if (*p == '&' && !mimic_gnu) {
 289                         add_sub(0, string, re, pm);
 290                         continue;
 291                 }
 292                 if (*p == '\\') {
 293                         if (p[1] == '\\') {
 294                                 addchar(p[1]);
 295                                 p++;
 296                                 continue;
 297                         }
 298                         if (p[1] == '&') {
 299                                 if (mimic_gnu)
 300                                         add_sub(0, string, re, pm);
 301                                 else
 302                                         addchar(p[1]);
 303                                 p++;
 304                                 continue;
 305                         }
 306                         if (isdigit((unsigned char)p[1])) {
 307                                 add_sub(*(++p) - '0', string, re, pm);
 308                                 continue;
 309                         }
 310                 }
 311                 addchar(*p);
 312         }
 313 }
 314
 315 static void
 316 do_subst(const char *string, regex_t *re, const char *replace, regmatch_t *pm)
 317 {
 318         int error;
 319         int flags = 0;
 320         const char *last_match = NULL;
 321
 322         while ((error = regexec(re, string, re->re_nsub+1, pm, flags)) == 0) {
 323                 if (pm[0].rm_eo != 0) {
 324                         if (string[pm[0].rm_eo-1] == '\n')
 325                                 flags = 0;
 326                         else
 327                                 flags = REG_NOTBOL;
 328                 }
 329
 330                 /* NULL length matches are special... We use the `vi-mode'
 331                  * rule: don't allow a NULL-match at the last match
 332                  * position.
 333                  */
 334                 if (pm[0].rm_so == pm[0].rm_eo &&
 335                     string + pm[0].rm_so == last_match) {
 336                         if (*string == '\0')
 337                                 return;
 338                         addchar(*string);
 339                         if (*string++ == '\n')
 340                                 flags = 0;
 341                         else
 342                                 flags = REG_NOTBOL;
 343                         continue;
 344                 }
 345                 last_match = string + pm[0].rm_so;
 346                 addchars(string, pm[0].rm_so);
 347                 add_replace(string, re, replace, pm);
 348                 string += pm[0].rm_eo;
 349         }
 350         if (error != REG_NOMATCH)
 351                 exit_regerror(error, re);
 352         pbstr(string);
 353 }
 354
 355 static void
 356 do_regexp(const char *string, regex_t *re, const char *replace, regmatch_t *pm)
 357 {
 358         int error;
 359
 360         switch(error = regexec(re, string, re->re_nsub+1, pm, 0)) {
 361         case 0:
 362                 add_replace(string, re, replace, pm);
 363                 pbstr(getstring());
 364                 break;
 365         case REG_NOMATCH:
 366                 break;
 367         default:
 368                 exit_regerror(error, re);
 369         }
 370 }
 371
 372 static void
 373 do_regexpindex(const char *string, regex_t *re, regmatch_t *pm)
 374 {
 375         int error;
 376
 377         switch(error = regexec(re, string, re->re_nsub+1, pm, 0)) {
 378         case 0:
 379                 pbunsigned(pm[0].rm_so);
 380                 break;
 381         case REG_NOMATCH:
 382                 pbnum(-1);
 383                 break;
 384         default:
 385                 exit_regerror(error, re);
 386         }
 387 }
 388
 389 /* In Gnu m4 mode, parentheses for backmatch don't work like POSIX 1003.2
 390  * says. So we twiddle with the regexp before passing it to regcomp.
 391  */
 392 static char *
 393 twiddle(const char *p)
 394 {
 395         /* + at start of regexp is a normal character for Gnu m4 */
 396         if (*p == '^') {
 397                 addchar(*p);
 398                 p++;
 399         }
 400         if (*p == '+') {
 401                 addchar('\\');
 402         }
 403         /* This could use strcspn for speed... */
 404         while (*p != '\0') {
 405                 if (*p == '\\') {
 406                         switch(p[1]) {
 407                         case '(':
 408                         case ')':
 409                         case '|':
 410                                 addchar(p[1]);
 411                                 break;
 412                         case 'w':
 413                                 addconstantstring("[_a-zA-Z0-9]");
 414                                 break;
 415                         case 'W':
 416                                 addconstantstring("[^_a-zA-Z0-9]");
 417                                 break;
 418                         case '<':
 419                                 addconstantstring("[[:<:]]");
 420                                 break;
 421                         case '>':
 422                                 addconstantstring("[[:>:]]");
 423                                 break;
 424                         default:
 425                                 addchars(p, 2);
 426                                 break;
 427                         }
 428                         p+=2;
 429                         continue;
 430                 }
 431                 if (*p == '(' || *p == ')' || *p == '|')
 432                         addchar('\\');
 433
 434                 addchar(*p);
 435                 p++;
 436         }
 437         return getstring();
 438 }
 439
 440 /* patsubst(string, regexp, opt replacement) */
 441 /* argv[2]: string
 442  * argv[3]: regexp
 443  * argv[4]: opt rep
 444  */
 445 void
 446 dopatsubst(const char *argv[], int argc)
 447 {
 448         if (argc <= 3) {
 449                 warnx("Too few arguments to patsubst");
 450                 return;
 451         }
 452         /* special case: empty regexp */
 453         if (argv[3][0] == '\0') {
 454                 const char *s;
 455                 size_t len;
 456                 if (argv[4] && argc > 4)
 457                         len = strlen(argv[4]);
 458                 else
 459                         len = 0;
 460                 for (s = argv[2]; *s != '\0'; s++) {
 461                         addchars(argv[4], len);
 462                         addchar(*s);
 463                 }
 464         } else {
 465                 int error;
 466                 regex_t re;
 467                 regmatch_t *pmatch;
 468                 int mode = REG_EXTENDED;
 469                 size_t l = strlen(argv[3]);
 470
 471                 if (!mimic_gnu ||
 472                     (argv[3][0] == '^') ||
 473                     (l > 0 && argv[3][l-1] == '$'))
 474                         mode |= REG_NEWLINE;
 475
 476                 error = regcomp(&re, mimic_gnu ? twiddle(argv[3]) : argv[3],
 477                     mode);
 478                 if (error != 0)
 479                         exit_regerror(error, &re);
 480
 481                 pmatch = xalloc(sizeof(regmatch_t) * (re.re_nsub+1), NULL);
 482                 do_subst(argv[2], &re,
 483                     argc > 4 && argv[4] != NULL ? argv[4] : "", pmatch);
 484                 free(pmatch);
 485                 regfree(&re);
 486         }
 487         pbstr(getstring());
 488 }
 489
 490 void
 491 doregexp(const char *argv[], int argc)
 492 {
 493         int error;
 494         regex_t re;
 495         regmatch_t *pmatch;
 496
 497         if (argc <= 3) {
 498                 warnx("Too few arguments to regexp");
 499                 return;
 500         }
 501         error = regcomp(&re, mimic_gnu ? twiddle(argv[3]) : argv[3],
 502             REG_EXTENDED);
 503         if (error != 0)
 504                 exit_regerror(error, &re);
 505
 506         pmatch = xalloc(sizeof(regmatch_t) * (re.re_nsub+1), NULL);
 507         if (argv[4] == NULL || argc == 4)
 508                 do_regexpindex(argv[2], &re, pmatch);
 509         else
 510                 do_regexp(argv[2], &re, argv[4], pmatch);
 511         free(pmatch);
 512         regfree(&re);
 513 }
 514
 515 void
 516 doformat(const char *argv[], int argc)
 517 {
 518         const char *format = argv[2];
 519         int pos = 3;
 520         int left_padded;
 521         long width;
 522         size_t l;
 523         const char *thisarg;
 524         char temp[2];
 525         size_t extra;
 526
 527         while (*format != 0) {
 528                 if (*format != '%') {
 529                         addchar(*format++);
 530                         continue;
 531                 }
 532
 533                 format++;
 534                 if (*format == '%') {
 535                         addchar(*format++);
 536                         continue;
 537                 }
 538                 if (*format == 0) {
 539                         addchar('%');
 540                         break;
 541                 }
 542
 543                 if (*format == '*') {
 544                         format++;
 545                         if (pos >= argc)
 546                                 m4errx(1,
 547                                     "Format with too many format specifiers.");
 548                         width = strtol(argv[pos++], NULL, 10);
 549                 } else {
 550                         char *eformat;
 551                         width = strtol(format, &eformat, 10);
 552                         format = eformat;
 553                 }
 554                 if (width < 0) {
 555                         left_padded = 1;
 556                         width = -width;
 557                 } else {
 558                         left_padded = 0;
 559                 }
 560                 if (*format == '.') {
 561                         format++;
 562                         if (*format == '*') {
 563                                 format++;
 564                                 if (pos >= argc)
 565                                         m4errx(1,
 566                                             "Format with too many format specifiers.");
 567                                 extra = strtol(argv[pos++], NULL, 10);
 568                         } else {
 569                                 char *eformat;
 570                                 extra = strtol(format, &eformat, 10);
 571                                 format = eformat;
 572                         }
 573                 } else {
 574                         extra = SIZE_T_MAX;
 575                 }
 576                 if (pos >= argc)
 577                         m4errx(1, "Format with too many format specifiers.");
 578                 switch(*format) {
 579                 case 's':
 580                         thisarg = argv[pos++];
 581                         break;
 582                 case 'c':
 583                         temp[0] = strtoul(argv[pos++], NULL, 10);
 584                         temp[1] = 0;
 585                         thisarg = temp;
 586                         break;
 587                 default:
 588                         m4errx(1, "Unsupported format specification: %s.",
 589                             argv[2]);
 590                 }
 591                 format++;
 592                 l = strlen(thisarg);
 593                 if (l > extra)
 594                         l = extra;
 595                 if (!left_padded) {
 596                         while (l < (size_t)width--)
 597                                 addchar(' ');
 598                 }
 599                 addchars(thisarg, l);
 600                 if (left_padded) {
 601                         while (l < (size_t)width--)
 602                                 addchar(' ');
 603                 }
 604         }
 605         pbstr(getstring());
 606 }
 607
 608 void
 609 doesyscmd(const char *cmd)
 610 {
 611         int p[2];
 612         pid_t pid, cpid;
 613         const char *argv[4];
 614         int cc;
 615         int status;
 616
 617         /* Follow gnu m4 documentation: first flush buffers. */
 618         fflush(NULL);
 619
 620         argv[0] = "sh";
 621         argv[1] = "-c";
 622         argv[2] = cmd;
 623         argv[3] = NULL;
 624
 625         /* Just set up standard output, share stderr and stdin with m4 */
 626         if (pipe(p) == -1)
 627                 err(1, "bad pipe");
 628         switch(cpid = fork()) {
 629         case -1:
 630                 err(1, "bad fork");
 631                 /* NOTREACHED */
 632         case 0:
 633                 (void) close(p[0]);
 634                 (void) dup2(p[1], 1);
 635                 (void) close(p[1]);
 636                 execv(_PATH_BSHELL, __UNCONST(argv));
 637                 exit(1);
 638         default:
 639                 /* Read result in two stages, since m4's buffer is
 640                  * pushback-only. */
 641                 (void) close(p[1]);
 642                 do {
 643                         char result[BUFSIZE];
 644                         cc = read(p[0], result, sizeof result);
 645                         if (cc > 0)
 646                                 addchars(result, cc);
 647                 } while (cc > 0 || (cc == -1 && errno == EINTR));
 648
 649                 (void) close(p[0]);
 650                 while ((pid = wait(&status)) != cpid && pid >= 0)
 651                         continue;
 652                 pbstr(getstring());
 653         }
 654 }
 655
 656 void
 657 getdivfile(const char *name)
 658 {
 659         FILE *f;
 660         int c;
 661
 662         f = fopen(name, "r");
 663         if (!f)
 664                 return;
 665
 666         while ((c = getc(f))!= EOF)
 667                 putc(c, active);
 668         (void) fclose(f);
 669 }