src/symlist.c

   1 /* Lists of symbols for Bison
   2
   3    Copyright (C) 2002, 2005-2007, 2009-2012 Free Software Foundation,
   4    Inc.
   5
   6    This file is part of Bison, the GNU Compiler Compiler.
   7
   8    This program is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include <config.h>
  22 #include "system.h"
  23
  24 #include "complain.h"
  25 #include "symlist.h"
  26
  27
  28 /*--------------------------------------.
  29 | Create a list containing SYM at LOC.  |
  30 `--------------------------------------*/
  31
  32 symbol_list *
  33 symbol_list_sym_new (symbol *sym, location loc)
  34 {
  35   symbol_list *res = xmalloc (sizeof *res);
  36
  37   res->content_type = SYMLIST_SYMBOL;
  38   res->content.sym = sym;
  39   res->location = res->sym_loc = loc;
  40
  41   res->midrule = NULL;
  42   res->midrule_parent_rule = NULL;
  43   res->midrule_parent_rhs_index = 0;
  44
  45   code_props_none_init (&res->action_props);
  46
  47   res->ruleprec = NULL;
  48   res->dprec = 0;
  49   res->merger = 0;
  50
  51   res->named_ref = NULL;
  52
  53   res->next = NULL;
  54
  55   return res;
  56 }
  57
  58
  59 /*--------------------------------------------.
  60 | Create a list containing TYPE_NAME at LOC.  |
  61 `--------------------------------------------*/
  62
  63 symbol_list *
  64 symbol_list_type_new (uniqstr type_name, location loc)
  65 {
  66   symbol_list *res = xmalloc (sizeof *res);
  67
  68   res->content_type = SYMLIST_TYPE;
  69   res->content.sem_type = xmalloc (sizeof (semantic_type));
  70   res->content.sem_type->tag = type_name;
  71   res->content.sem_type->location = loc;
  72   res->content.sem_type->status = undeclared;
  73
  74   res->location = res->sym_loc = loc;
  75   res->named_ref = NULL;
  76   res->next = NULL;
  77
  78   return res;
  79 }
  80
  81
  82 /*----------------------------------------.
  83 | Create a list containing a <*> at LOC.  |
  84 `----------------------------------------*/
  85
  86 symbol_list *
  87 symbol_list_default_tagged_new (location loc)
  88 {
  89   symbol_list *res = xmalloc (sizeof *res);
  90
  91   res->content_type = SYMLIST_DEFAULT_TAGGED;
  92   res->location = res->sym_loc = loc;
  93   res->named_ref = NULL;
  94   res->next = NULL;
  95
  96   return res;
  97 }
  98
  99
 100 /*---------------------------------------.
 101 | Create a list containing a <> at LOC.  |
 102 `---------------------------------------*/
 103
 104 symbol_list *
 105 symbol_list_default_tagless_new (location loc)
 106 {
 107   symbol_list *res = xmalloc (sizeof *res);
 108
 109   res->content_type = SYMLIST_DEFAULT_TAGLESS;
 110   res->location = res->sym_loc = loc;
 111   res->named_ref = NULL;
 112   res->next = NULL;
 113
 114   return res;
 115 }
 116
 117
 118 /*-----------------------------------------------------------------------.
 119 | Print this list, for which every content_type must be SYMLIST_SYMBOL.  |
 120 `-----------------------------------------------------------------------*/
 121
 122 void
 123 symbol_list_syms_print (const symbol_list *l, FILE *f)
 124 {
 125   for (/* Nothing. */; l && l->content.sym; l = l->next)
 126     {
 127       symbol_print (l->content.sym, f);
 128       fprintf (stderr, l->action_props.is_value_used ? " used" : " unused");
 129       if (l && l->content.sym)
 130         fprintf (f, ", ");
 131     }
 132 }
 133
 134
 135 /*---------------------------.
 136 | Prepend NODE to the LIST.  |
 137 `---------------------------*/
 138
 139 symbol_list *
 140 symbol_list_prepend (symbol_list *list, symbol_list *node)
 141 {
 142   node->next = list;
 143   return node;
 144 }
 145
 146
 147 /*-----------------------------------------------.
 148 | Free the LIST, but not the items it contains.  |
 149 `-----------------------------------------------*/
 150
 151 void
 152 symbol_list_free (symbol_list *list)
 153 {
 154   symbol_list *node, *next;
 155   for (node = list; node; node = next)
 156     {
 157       next = node->next;
 158       named_ref_free (node->named_ref);
 159       free (node);
 160     }
 161 }
 162
 163
 164 /*--------------------.
 165 | Return its length.  |
 166 `--------------------*/
 167
 168 int
 169 symbol_list_length (symbol_list const *l)
 170 {
 171   int res = 0;
 172   for (/* Nothing. */;
 173        l && !(l->content_type == SYMLIST_SYMBOL && l->content.sym == NULL);
 174        l = l->next)
 175     ++res;
 176   return res;
 177 }
 178
 179
 180 /*------------------------------.
 181 | Get item N in symbol list L.  |
 182 `------------------------------*/
 183
 184 symbol_list *
 185 symbol_list_n_get (symbol_list *l, int n)
 186 {
 187   int i;
 188
 189   if (n < 0)
 190     return NULL;
 191
 192   for (i = 0; i < n; ++i)
 193     {
 194       l = l->next;
 195       if (l == NULL
 196           || (l->content_type == SYMLIST_SYMBOL && l->content.sym == NULL))
 197         return NULL;
 198     }
 199
 200   return l;
 201 }
 202
 203
 204 /*--------------------------------------------------------------.
 205 | Get the data type (alternative in the union) of the value for |
 206 | symbol N in symbol list L.                                    |
 207 `--------------------------------------------------------------*/
 208
 209 uniqstr
 210 symbol_list_n_type_name_get (symbol_list *l, location loc, int n)
 211 {
 212   l = symbol_list_n_get (l, n);
 213   if (!l)
 214     {
 215       complain_at (loc, _("invalid $ value: $%d"), n);
 216       return NULL;
 217     }
 218   aver (l->content_type == SYMLIST_SYMBOL);
 219   return l->content.sym->type_name;
 220 }
 221
 222 bool
 223 symbol_list_null (symbol_list *node)
 224 {
 225   return !node ||
 226     (node->content_type == SYMLIST_SYMBOL && !(node->content.sym));
 227 }
 228
 229 void
 230 symbol_list_code_props_set (symbol_list *node, code_props_type kind,
 231                             location loc, char const *code)
 232 {
 233   code_props cprops;
 234   code_props_symbol_action_init (&cprops, code, loc);
 235   code_props_translate_code (&cprops);
 236   switch (node->content_type)
 237     {
 238       case SYMLIST_SYMBOL:
 239         symbol_code_props_set (node->content.sym, kind, &cprops);
 240         if (node->content.sym->status == undeclared)
 241           node->content.sym->status = used;
 242         break;
 243       case SYMLIST_TYPE:
 244         semantic_type_code_props_set
 245           (semantic_type_get (node->content.sem_type->tag,
 246                               &node->content.sem_type->location),
 247            kind, &cprops);
 248         if (node->content.sem_type->status == undeclared)
 249           node->content.sem_type->status = used;
 250         break;
 251       case SYMLIST_DEFAULT_TAGGED:
 252         default_tagged_code_props_set (kind, &cprops);
 253         break;
 254       case SYMLIST_DEFAULT_TAGLESS:
 255         default_tagless_code_props_set (kind, &cprops);
 256         break;
 257     }
 258 }