usr.bin/m4/misc.c

   1 /*      $OpenBSD: misc.c,v 1.41 2009/10/14 17:19:47 sthen Exp $ */
   2 /*      $NetBSD: misc.c,v 1.20 2009/11/06 15:13:27 joerg 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 #if HAVE_NBTOOL_CONFIG_H
  36 #include "nbtool_config.h"
  37 #endif
  38 #include <sys/cdefs.h>
  39 __RCSID("$NetBSD: misc.c,v 1.20 2009/11/06 15:13:27 joerg Exp $");
  40 #include <sys/types.h>
  41 #include <errno.h>
  42 #include <unistd.h>
  43 #include <stdarg.h>
  44 #include <stdio.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 ((size_t)(endpbb - bp) <= 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()
 164 {
 165         int i;
 166
 167         strspace = xalloc(strsize+1, NULL);
 168         ep = strspace;
 169         endest = strspace+strsize;
 170         buf = (unsigned char *)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()
 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()
 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)
 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()
 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 void
 266 m4errx(int exval, const char *fmt, ...)
 267 {
 268         fprintf(stderr, "%s: ", getprogname());
 269         fprintf(stderr, "%s at line %lu: ", CURRENT_NAME, CURRENT_LINE);
 270         if (fmt != NULL) {
 271                 va_list ap;
 272
 273                 va_start(ap, fmt);
 274                 vfprintf(stderr, fmt, ap);
 275                 va_end(ap);
 276         }
 277         fprintf(stderr, "\n");
 278         exit(exval);
 279 }
 280
 281 /*
 282  * resizedivs: allocate more diversion files */
 283 void
 284 resizedivs(int n)
 285 {
 286         int i;
 287
 288         outfile = (FILE **)xrealloc(outfile, sizeof(FILE *) * n,
 289             "too many diverts %d", n);
 290         for (i = maxout; i < n; i++)
 291                 outfile[i] = NULL;
 292         maxout = n;
 293 }
 294
 295 void *
 296 xalloc(size_t n, const char *fmt, ...)
 297 {
 298         void *p = malloc(n);
 299
 300         if (p == NULL) {
 301                 if (fmt == NULL)
 302                         err(1, "malloc");
 303                 else {
 304                         va_list va;
 305
 306                         va_start(va, fmt);
 307                         verr(1, fmt, va);
 308                         va_end(va);
 309                 }
 310         }
 311         return p;
 312 }
 313
 314 void *
 315 xrealloc(void *old, size_t n, const char *fmt, ...)
 316 {
 317         char *p = realloc(old, n);
 318
 319         if (p == NULL) {
 320                 free(old);
 321                 if (fmt == NULL)
 322                         err(1, "realloc");
 323                 else {
 324                         va_list va;
 325
 326                         va_start(va, fmt);
 327                         verr(1, fmt, va);
 328                         va_end(va);
 329                 }
 330         }
 331         return p;
 332 }
 333
 334 char *
 335 xstrdup(const char *s)
 336 {
 337         char *p = strdup(s);
 338         if (p == NULL)
 339                 err(1, "strdup");
 340         return p;
 341 }
 342
 343 void
 344 usage(void)
 345 {
 346         fprintf(stderr, "usage: %s [-gPs] [-Dname[=value]] [-d flags] "
 347                         "[-I dirname] [-o filename]\n"
 348                         "\t[-t macro] [-Uname] [file ...]\n", getprogname());
 349         exit(1);
 350 }
 351
 352 int
 353 obtain_char(struct input_file *f)
 354 {
 355         if (f->c == EOF)
 356                 return EOF;
 357
 358         f->c = fgetc(f->file);
 359         if (f->c == '\n')
 360                 f->lineno++;
 361
 362         return f->c;
 363 }
 364
 365 void
 366 set_input(struct input_file *f, FILE *real, const char *name)
 367 {
 368         f->file = real;
 369         f->lineno = 1;
 370         f->c = 0;
 371         f->name = xstrdup(name);
 372         emit_synchline();
 373 }
 374
 375 void
 376 do_emit_synchline()
 377 {
 378         fprintf(active, "#line %lu \"%s\"\n",
 379             infile[ilevel].lineno, infile[ilevel].name);
 380         infile[ilevel].synch_lineno = infile[ilevel].lineno;
 381 }
 382
 383 void
 384 release_input(struct input_file *f)
 385 {
 386         if (f->file != stdin)
 387             fclose(f->file);
 388         f->c = EOF;
 389         /*
 390          * XXX can't free filename, as there might still be
 391          * error information pointing to it.
 392          */
 393 }
 394
 395 void
 396 doprintlineno(struct input_file *f)
 397 {
 398         pbunsigned(f->lineno);
 399 }
 400
 401 void
 402 doprintfilename(struct input_file *f)
 403 {
 404         pbstr(rquote);
 405         pbstr(f->name);
 406         pbstr(lquote);
 407 }
 408
 409 /*
 410  * buffer_mark/dump_buffer: allows one to save a mark in a buffer,
 411  * and later dump everything that was added since then to a file.
 412  */
 413 size_t
 414 buffer_mark()
 415 {
 416         return bp - buf;
 417 }
 418
 419
 420 void
 421 dump_buffer(FILE *f, size_t m)
 422 {
 423         unsigned char *s;
 424
 425         for (s = bp; (size_t)(s - buf) > m;)
 426                 fputc(*--s, f);
 427 }