usr.bin/m4/misc.c

   1 /*      $OpenBSD: misc.c,v 1.44 2014/05/12 19:11:19 espie Exp $ */
   2 /*      $NetBSD: misc.c,v 1.6 1995/09/28 05:37:41 tls 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 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include <sys/types.h>
  40 #include <errno.h>
  41 #include <unistd.h>
  42 #include <stdarg.h>
  43 #include <stdio.h>
  44 #include <stdint.h>
  45 #include <stdlib.h>
  46 #include <stddef.h>
  47 #include <string.h>
  48 #include <err.h>
  49 #include "mdef.h"
  50 #include "stdd.h"
  51 #include "extern.h"
  52 #include "pathnames.h"
  53
  54
  55 char *ep;               /* first free char in strspace */
  56 static char *strspace;  /* string space for evaluation */
  57 char *endest;           /* end of string space         */
  58 static size_t strsize = STRSPMAX;
  59 static size_t bufsize = BUFSIZE;
  60
  61 unsigned char *buf;                     /* push-back buffer            */
  62 unsigned char *bufbase;                 /* the base for current ilevel */
  63 unsigned char *bbase[MAXINP];           /* the base for each ilevel    */
  64 unsigned char *bp;                      /* first available character   */
  65 unsigned char *endpbb;                  /* end of push-back buffer     */
  66
  67
  68 /*
  69  * find the index of second str in the first str.
  70  */
  71 ptrdiff_t
  72 indx(const char *s1, const char *s2)
  73 {
  74         char *t;
  75
  76         t = strstr(s1, s2);
  77         if (t == NULL)
  78                 return (-1);
  79         else
  80                 return (t - s1);
  81 }
  82 /*
  83  *  pushback - push character back onto input
  84  */
  85 void
  86 pushback(int c)
  87 {
  88         if (c == EOF)
  89                 return;
  90         if (bp >= endpbb)
  91                 enlarge_bufspace();
  92         *bp++ = c;
  93 }
  94
  95 /*
  96  *  pbstr - push string back onto input
  97  *          pushback is replicated to improve
  98  *          performance.
  99  */
 100 void
 101 pbstr(const char *s)
 102 {
 103         size_t n;
 104
 105         n = strlen(s);
 106         while (endpbb - bp <= (long)n)
 107                 enlarge_bufspace();
 108         while (n > 0)
 109                 *bp++ = s[--n];
 110 }
 111
 112 /*
 113  *  pbnum - convert number to string, push back on input.
 114  */
 115 void
 116 pbnum(int n)
 117 {
 118         pbnumbase(n, 10, 0);
 119 }
 120
 121 void
 122 pbnumbase(int n, int base, int d)
 123 {
 124         static char digits[36] = "0123456789abcdefghijklmnopqrstuvwxyz";
 125         int num;
 126         int printed = 0;
 127
 128         if (base > 36)
 129                 m4errx(1, "base %d > 36: not supported.", base);
 130
 131         if (base < 2)
 132                 m4errx(1, "bad base %d for conversion.", base);
 133
 134         num = (n < 0) ? -n : n;
 135         do {
 136                 pushback(digits[num % base]);
 137                 printed++;
 138         }
 139         while ((num /= base) > 0);
 140
 141         if (n < 0)
 142                 printed++;
 143         while (printed++ < d)
 144                 pushback('0');
 145
 146         if (n < 0)
 147                 pushback('-');
 148 }
 149
 150 /*
 151  *  pbunsigned - convert unsigned long to string, push back on input.
 152  */
 153 void
 154 pbunsigned(unsigned long n)
 155 {
 156         do {
 157                 pushback(n % 10 + '0');
 158         }
 159         while ((n /= 10) > 0);
 160 }
 161
 162 void
 163 initspaces(void)
 164 {
 165         int i;
 166
 167         strspace = xalloc(strsize+1, NULL);
 168         ep = strspace;
 169         endest = strspace+strsize;
 170         buf = xalloc(bufsize, NULL);
 171         bufbase = buf;
 172         bp = buf;
 173         endpbb = buf + bufsize;
 174         for (i = 0; i < MAXINP; i++)
 175                 bbase[i] = buf;
 176 }
 177
 178 void
 179 enlarge_strspace(void)
 180 {
 181         char *newstrspace;
 182         int i;
 183
 184         strsize *= 2;
 185         newstrspace = malloc(strsize + 1);
 186         if (!newstrspace)
 187                 errx(1, "string space overflow");
 188         memcpy(newstrspace, strspace, strsize/2);
 189         for (i = 0; i <= sp; i++)
 190                 if (sstack[i])
 191                         mstack[i].sstr = (mstack[i].sstr - strspace)
 192                             + newstrspace;
 193         ep = (ep-strspace) + newstrspace;
 194         free(strspace);
 195         strspace = newstrspace;
 196         endest = strspace + strsize;
 197 }
 198
 199 void
 200 enlarge_bufspace(void)
 201 {
 202         unsigned char *newbuf;
 203         int i;
 204
 205         bufsize += bufsize/2;
 206         newbuf = xrealloc(buf, bufsize, "too many characters pushed back");
 207         for (i = 0; i < MAXINP; i++)
 208                 bbase[i] = (bbase[i]-buf)+newbuf;
 209         bp = (bp-buf)+newbuf;
 210         bufbase = (bufbase-buf)+newbuf;
 211         buf = newbuf;
 212         endpbb = buf+bufsize;
 213 }
 214
 215 /*
 216  *  chrsave - put single char on string space
 217  */
 218 void
 219 chrsave(int c)
 220 {
 221         if (ep >= endest)
 222                 enlarge_strspace();
 223         *ep++ = c;
 224 }
 225
 226 /*
 227  * read in a diversion file, and dispose it.
 228  */
 229 void
 230 getdiv(int n)
 231 {
 232         int c;
 233
 234         if (active == outfile[n])
 235                 m4errx(1, "undivert: diversion still active.");
 236         rewind(outfile[n]);
 237         while ((c = getc(outfile[n])) != EOF)
 238                 putc(c, active);
 239         (void) fclose(outfile[n]);
 240         outfile[n] = NULL;
 241 }
 242
 243 void
 244 onintr(int signo __unused)
 245 {
 246 #define intrmessage     "m4: interrupted.\n"
 247         write(STDERR_FILENO, intrmessage, sizeof(intrmessage)-1);
 248         _exit(1);
 249 }
 250
 251 /*
 252  * killdiv - get rid of the diversion files
 253  */
 254 void
 255 killdiv(void)
 256 {
 257         int n;
 258
 259         for (n = 0; n < maxout; n++)
 260                 if (outfile[n] != NULL) {
 261                         (void) fclose(outfile[n]);
 262                 }
 263 }
 264
 265 extern char *__progname;
 266
 267 void
 268 m4errx(int eval, const char *fmt, ...)
 269 {
 270         fprintf(stderr, "%s: ", __progname);
 271         fprintf(stderr, "%s at line %lu: ", CURRENT_NAME, CURRENT_LINE);
 272         if (fmt != NULL) {
 273                 va_list ap;
 274
 275                 va_start(ap, fmt);
 276                 vfprintf(stderr, fmt, ap);
 277                 va_end(ap);
 278         }
 279         fprintf(stderr, "\n");
 280         exit(eval);
 281 }
 282
 283 /*
 284  * resizedivs: allocate more diversion files */
 285 void
 286 resizedivs(int n)
 287 {
 288         int i;
 289
 290         outfile = xreallocarray(outfile, n, sizeof(FILE *),
 291             "too many diverts %d", n);
 292         for (i = maxout; i < n; i++)
 293                 outfile[i] = NULL;
 294         maxout = n;
 295 }
 296
 297 void *
 298 xalloc(size_t n, const char *fmt, ...)
 299 {
 300         void *p = malloc(n);
 301
 302         if (p == NULL) {
 303                 if (fmt == NULL)
 304                         err(1, "malloc");
 305                 else {
 306                         va_list va;
 307
 308                         va_start(va, fmt);
 309                         verr(1, fmt, va);
 310                         va_end(va);
 311                 }
 312         }
 313         return p;
 314 }
 315
 316 void *
 317 xcalloc(size_t n, size_t s, const char *fmt, ...)
 318 {
 319         void *p = calloc(n, s);
 320
 321         if (p == NULL) {
 322                 if (fmt == NULL)
 323                         err(1, "calloc");
 324                 else {
 325                         va_list va;
 326
 327                         va_start(va, fmt);
 328                         verr(1, fmt, va);
 329                         va_end(va);
 330                 }
 331         }
 332         return p;
 333 }
 334
 335 void *
 336 xrealloc(void *old, size_t n, const char *fmt, ...)
 337 {
 338         char *p = realloc(old, n);
 339
 340         if (p == NULL) {
 341                 free(old);
 342                 if (fmt == NULL)
 343                         err(1, "realloc");
 344                 else {
 345                         va_list va;
 346
 347                         va_start(va, fmt);
 348                         verr(1, fmt, va);
 349                         va_end(va);
 350                 }
 351         }
 352         return p;
 353 }
 354
 355 /*
 356  * This is sqrt(SIZE_MAX+1), as s1*s2 <= SIZE_MAX
 357  * if both s1 < MUL_NO_OVERFLOW and s2 < MUL_NO_OVERFLOW
 358  */
 359 #define MUL_NO_OVERFLOW (1UL << (sizeof(size_t) * 4))
 360
 361 static void *
 362 reallocarray(void *optr, size_t nmemb, size_t size)
 363 {
 364         if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) &&
 365             nmemb > 0 && SIZE_MAX / nmemb < size) {
 366                 errno = ENOMEM;
 367                 return NULL;
 368         }
 369         return realloc(optr, size * nmemb);
 370 }
 371
 372 void *
 373 xreallocarray(void *old, size_t s1, size_t s2, const char *fmt, ...)
 374 {
 375         void *p = reallocarray(old, s1, s2);
 376
 377         if (p == NULL) {
 378                 free(old);
 379                 if (fmt == NULL)
 380                         err(1, "reallocarray");
 381                 else {
 382                         va_list va;
 383
 384                         va_start(va, fmt);
 385                         verr(1, fmt, va);
 386                         va_end(va);
 387                 }
 388         }
 389         return p;
 390 }
 391
 392 char *
 393 xstrdup(const char *s)
 394 {
 395         char *p = strdup(s);
 396         if (p == NULL)
 397                 err(1, "strdup");
 398         return p;
 399 }
 400
 401 void
 402 usage(void)
 403 {
 404         fprintf(stderr, "usage: m4 [-gPs] [-Dname[=value]] [-d flags] "
 405                         "[-I dirname] [-o filename]\n"
 406                         "\t[-t macro] [-Uname] [file ...]\n");
 407         exit(1);
 408 }
 409
 410 int
 411 obtain_char(struct input_file *f)
 412 {
 413         if (f->c == EOF)
 414                 return EOF;
 415
 416         f->c = fgetc(f->file);
 417         if (f->c == '\n')
 418                 f->lineno++;
 419
 420         return f->c;
 421 }
 422
 423 void
 424 set_input(struct input_file *f, FILE *real, const char *name)
 425 {
 426         f->file = real;
 427         f->lineno = 1;
 428         f->c = 0;
 429         f->name = xstrdup(name);
 430         emit_synchline();
 431 }
 432
 433 void
 434 do_emit_synchline(void)
 435 {
 436         fprintf(active, "#line %lu \"%s\"\n",
 437             infile[ilevel].lineno, infile[ilevel].name);
 438         infile[ilevel].synch_lineno = infile[ilevel].lineno;
 439 }
 440
 441 void
 442 release_input(struct input_file *f)
 443 {
 444         if (f->file != stdin)
 445             fclose(f->file);
 446         f->c = EOF;
 447         /*
 448          * XXX can't free filename, as there might still be
 449          * error information pointing to it.
 450          */
 451 }
 452
 453 void
 454 doprintlineno(struct input_file *f)
 455 {
 456         pbunsigned(f->lineno);
 457 }
 458
 459 void
 460 doprintfilename(struct input_file *f)
 461 {
 462         pbstr(rquote);
 463         pbstr(f->name);
 464         pbstr(lquote);
 465 }
 466
 467 /*
 468  * buffer_mark/dump_buffer: allows one to save a mark in a buffer,
 469  * and later dump everything that was added since then to a file.
 470  */
 471 size_t
 472 buffer_mark(void)
 473 {
 474         return bp - buf;
 475 }
 476
 477
 478 void
 479 dump_buffer(FILE *f, size_t m)
 480 {
 481         unsigned char *s;
 482
 483         for (s = bp; s-buf > (long)m;)
 484                 fputc(*--s, f);
 485 }