nasmlib/strlist.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * strlist.c - list of ordered strings, optionally made unique
  36  */
  37
  38 #include "strlist.h"
  39
  40 /*
  41  * Create a string list. The list can be uniqizing or not.
  42  */
  43 struct strlist *strlist_alloc(bool uniq)
  44 {
  45         struct strlist *list = nasm_zalloc(sizeof(*list));
  46         list->tailp = &list->head;
  47         list->uniq = uniq;
  48         return list;
  49 }
  50
  51 /*
  52  * Append a string to a string list. Return the entry pointer, which
  53  * may be a pre-existing entry for a uniqizing list.
  54  */
  55
  56 static const struct strlist_entry *
  57 strlist_add_common(struct strlist *list, struct strlist_entry *e,
  58                    struct hash_insert *hi)
  59 {
  60         e->offset = list->size;
  61         e->next = NULL;
  62
  63         *list->tailp = e;
  64         list->tailp = &e->next;
  65         list->nstr++;
  66         list->size += e->size;
  67
  68         if (list->uniq)
  69                 hash_add(hi, e->str, (void *)e);
  70
  71         return e;
  72 }
  73
  74 const struct strlist_entry *
  75 strlist_add(struct strlist *list, const char *str)
  76 {
  77         struct strlist_entry *e;
  78         struct hash_insert hi;
  79         size_t size;
  80
  81         if (!list)
  82                 return NULL;
  83
  84         size = strlen(str) + 1;
  85         if (list->uniq) {
  86                 void **dp = hash_findb(&list->hash, str, size, &hi);
  87                 if (dp)
  88                         return *dp;
  89         }
  90
  91         /* Structure already has char[1] as EOS */
  92         e = nasm_malloc(sizeof(*e) - 1 + size);
  93         e->size = size;
  94         memcpy(e->str, str, size);
  95
  96         return strlist_add_common(list, e, &hi);
  97 }
  98
  99 /*
 100  * printf() to a string list
 101  */
 102 const struct strlist_entry *
 103 strlist_vprintf(struct strlist *list, const char *fmt, va_list ap)
 104 {
 105         /* clang miscompiles offsetin() unless e is initialized here */
 106         struct strlist_entry *e = NULL;
 107         struct hash_insert hi;
 108
 109         if (!list)
 110                 return NULL;
 111
 112         e = nasm_vaxprintf(offsetin(*e, str), fmt, ap);
 113         e->size = nasm_last_string_size();
 114
 115         if (list->uniq) {
 116                 void **dp = hash_findb(&list->hash, e->str, e->size, &hi);
 117                 if (dp) {
 118                         nasm_free(e);
 119                         return *dp;
 120                 }
 121         }
 122
 123         return strlist_add_common(list, e, &hi);
 124 }
 125
 126 const struct strlist_entry *
 127 strlist_printf(struct strlist *list, const char *fmt, ...)
 128 {
 129         va_list ap;
 130         const struct strlist_entry *e;
 131
 132         va_start(ap, fmt);
 133         e = strlist_vprintf(list, fmt, ap);
 134         va_end(ap);
 135
 136         return e;
 137 }
 138
 139 /*
 140  * Free a string list. Sets the pointed to pointer to NULL.
 141  */
 142 void strlist_free(struct strlist **listp)
 143 {
 144         struct strlist *list = *listp;
 145         struct strlist_entry *e, *tmp;
 146
 147         if (!list)
 148                 return;
 149
 150         if (list->uniq)
 151                 hash_free(&list->hash);
 152
 153         list_for_each_safe(e, tmp, list->head)
 154                 nasm_free(e);
 155
 156         nasm_free(list);
 157         *listp = NULL;
 158 }
 159
 160 /*
 161  * Search the string list for an entry. If found, return the entry pointer.
 162  * Only possible on a uniqizing list.
 163  */
 164 const struct strlist_entry *
 165 strlist_find(const struct strlist *list, const char *str)
 166 {
 167         void **hf;
 168
 169         nasm_assert(list->uniq);
 170
 171         hf = hash_find((struct hash_table *)&list->hash, str, NULL);
 172         return hf ? *hf : NULL;
 173 }
 174
 175 /*
 176  * Produce a linearized buffer containing the whole list, in order;
 177  * The character "sep" is the separator between strings; this is
 178  * typically either 0 or '\n'. strlist_size() will give the size of
 179  * the returned buffer.
 180  */
 181 void *strlist_linearize(const struct strlist *list, char sep)
 182 {
 183         const struct strlist_entry *sl;
 184         char *buf = nasm_malloc(list->size);
 185         char *p = buf;
 186
 187         strlist_for_each(sl, list) {
 188                 p = mempcpy(p, sl->str, sl->size);
 189                 p[-1] = sep;
 190         }
 191
 192         return buf;
 193 }
 194
 195 /*
 196  * Output a string list to a file. The separator can be any string.
 197  */
 198 void strlist_write(const struct strlist *list, const char *sep, FILE *f)
 199 {
 200         const struct strlist_entry *sl;
 201         size_t seplen = strlen(sep);
 202
 203         strlist_for_each(sl, list) {
 204                 fwrite(sl->str, 1, sl->size - 1, f);
 205                 fwrite(sep, 1, seplen, f);
 206         }
 207 }