usr.bin/m4/look.c

   1 /*      $NetBSD: look.c,v 1.12 2012/03/20 20:34:58 matt Exp $   */
   2 /*      $OpenBSD: look.c,v 1.21 2009/10/14 17:23:17 sthen 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  * look.c
  38  * Facility: m4 macro processor
  39  * by: oz
  40  */
  41 #if HAVE_NBTOOL_CONFIG_H
  42 #include "nbtool_config.h"
  43 #endif
  44 #include <sys/cdefs.h>
  45 __RCSID("$NetBSD: look.c,v 1.12 2012/03/20 20:34:58 matt Exp $");
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <stdint.h>
  49 #include <stddef.h>
  50 #include <string.h>
  51 #include <ohash.h>
  52 #include "mdef.h"
  53 #include "stdd.h"
  54 #include "extern.h"
  55
  56 static void *hash_alloc(size_t, void *);
  57 static void hash_free(void *, size_t, void *);
  58 static void *element_alloc(size_t, void *);
  59 static void setup_definition(struct macro_definition *, const char *,
  60     const char *);
  61
  62 static struct ohash_info macro_info = {
  63         offsetof(struct ndblock, name),
  64         NULL, hash_alloc, hash_free, element_alloc };
  65
  66 struct ohash macros;
  67
  68 /* Support routines for hash tables.  */
  69 void *
  70 hash_alloc(size_t s, void *u UNUSED)
  71 {
  72         void *storage = xalloc(s, "hash alloc");
  73         if (storage)
  74                 memset(storage, 0, s);
  75         return storage;
  76 }
  77
  78 void
  79 hash_free(void *p, size_t s UNUSED, void *u UNUSED)
  80 {
  81         free(p);
  82 }
  83
  84 void *
  85 element_alloc(size_t s, void *u UNUSED)
  86 {
  87         return xalloc(s, "element alloc");
  88 }
  89
  90 void
  91 init_macros(void)
  92 {
  93         ohash_init(&macros, 10, &macro_info);
  94 }
  95
  96 /*
  97  * find name in the hash table
  98  */
  99 ndptr
 100 lookup(const char *name)
 101 {
 102         return ohash_find(&macros, ohash_qlookup(&macros, name));
 103 }
 104
 105 struct macro_definition *
 106 lookup_macro_definition(const char *name)
 107 {
 108         ndptr p;
 109
 110         p = ohash_find(&macros, ohash_qlookup(&macros, name));
 111         if (p)
 112                 return p->d;
 113         else
 114                 return NULL;
 115 }
 116
 117 static void
 118 setup_definition(struct macro_definition *d, const char *defn, const char *name)
 119 {
 120         ndptr p;
 121
 122         if (strncmp(defn, BUILTIN_MARKER, sizeof(BUILTIN_MARKER)-1) == 0 &&
 123             (p = macro_getbuiltin(defn+sizeof(BUILTIN_MARKER)-1)) != NULL) {
 124                 d->type = macro_builtin_type(p);
 125                 d->defn = xstrdup(defn+sizeof(BUILTIN_MARKER)-1);
 126         } else {
 127                 if (!*defn)
 128                         d->defn = xstrdup(null);
 129                 else
 130                         d->defn = xstrdup(defn);
 131                 d->type = MACRTYPE;
 132         }
 133         if (STREQ(name, defn))
 134                 d->type |= RECDEF;
 135 }
 136
 137 static ndptr
 138 create_entry(const char *name)
 139 {
 140         const char *end = NULL;
 141         unsigned int i;
 142         ndptr n;
 143
 144         i = ohash_qlookupi(&macros, name, &end);
 145         n = ohash_find(&macros, i);
 146         if (n == NULL) {
 147                 n = ohash_create_entry(&macro_info, name, &end);
 148                 ohash_insert(&macros, i, n);
 149                 n->trace_flags = FLAG_NO_TRACE;
 150                 n->builtin_type = MACRTYPE;
 151                 n->d = NULL;
 152         }
 153         return n;
 154 }
 155
 156 void
 157 macro_define(const char *name, const char *defn)
 158 {
 159         ndptr n = create_entry(name);
 160         if (n->d != NULL) {
 161                 if (n->d->defn != null)
 162                         free(n->d->defn);
 163         } else {
 164                 n->d = xalloc(sizeof(struct macro_definition), NULL);
 165                 n->d->next = NULL;
 166         }
 167         setup_definition(n->d, defn, name);
 168 }
 169
 170 void
 171 macro_pushdef(const char *name, const char *defn)
 172 {
 173         ndptr n;
 174         struct macro_definition *d;
 175
 176         n = create_entry(name);
 177         d = xalloc(sizeof(struct macro_definition), NULL);
 178         d->next = n->d;
 179         n->d = d;
 180         setup_definition(n->d, defn, name);
 181 }
 182
 183 void
 184 macro_undefine(const char *name)
 185 {
 186         ndptr n = lookup(name);
 187         if (n != NULL) {
 188                 struct macro_definition *r, *r2;
 189
 190                 for (r = n->d; r != NULL; r = r2) {
 191                         r2 = r->next;
 192                         if (r->defn != null)
 193                                 free(r->defn);
 194                         free(r);
 195                 }
 196                 n->d = NULL;
 197         }
 198 }
 199
 200 void
 201 macro_popdef(const char *name)
 202 {
 203         ndptr n = lookup(name);
 204
 205         if (n != NULL) {
 206                 struct macro_definition *r = n->d;
 207                 if (r != NULL) {
 208                         n->d = r->next;
 209                         if (r->defn != null)
 210                                 free(r->defn);
 211                         free(r);
 212                 }
 213         }
 214 }
 215
 216 void
 217 macro_for_all(void (*f)(const char *, struct macro_definition *))
 218 {
 219         ndptr n;
 220         unsigned int i;
 221
 222         for (n = ohash_first(&macros, &i); n != NULL;
 223             n = ohash_next(&macros, &i))
 224                 if (n->d != NULL)
 225                         f(n->name, n->d);
 226 }
 227
 228 void
 229 setup_builtin(const char *name, unsigned int type)
 230 {
 231         ndptr n;
 232         char *name2;
 233
 234         if (prefix_builtins) {
 235                 name2 = xalloc(strlen(name)+3+1, NULL);
 236                 memcpy(name2, "m4_", 3);
 237                 memcpy(name2 + 3, name, strlen(name)+1);
 238         } else
 239                 name2 = xstrdup(name);
 240
 241         n = create_entry(name2);
 242         n->builtin_type = type;
 243         n->d = xalloc(sizeof(struct macro_definition), NULL);
 244         n->d->defn = name2;
 245         n->d->type = type;
 246         n->d->next = NULL;
 247 }
 248
 249 void
 250 mark_traced(const char *name, int on)
 251 {
 252         ndptr p;
 253         unsigned int i;
 254
 255         if (name == NULL) {
 256                 if (on)
 257                         trace_flags |= TRACE_ALL;
 258                 else
 259                         trace_flags &= ~TRACE_ALL;
 260                 for (p = ohash_first(&macros, &i); p != NULL;
 261                     p = ohash_next(&macros, &i))
 262                         p->trace_flags = FLAG_NO_TRACE;
 263         } else {
 264                 p = create_entry(name);
 265                 p->trace_flags = on;
 266         }
 267 }
 268
 269 ndptr
 270 macro_getbuiltin(const char *name)
 271 {
 272         ndptr p;
 273
 274         p = lookup(name);
 275         if (p == NULL || p->builtin_type == MACRTYPE)
 276                 return NULL;
 277         else
 278                 return p;
 279 }
 280