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 | Create a list containing SYM at LOC.  |
  29 `--------------------------------------*/
  30
  31 symbol_list *
  32 symbol_list_sym_new (symbol *sym, location loc)
  33 {
  34   symbol_list *res = xmalloc (sizeof *res);
  35
  36   res->content_type = SYMLIST_SYMBOL;
  37   res->content.sym = sym;
  38   res->location = res->sym_loc = loc;
  39
  40   res->midrule = NULL;
  41   res->midrule_parent_rule = NULL;
  42   res->midrule_parent_rhs_index = 0;
  43
  44   code_props_none_init (&res->action_props);
  45
  46   res->ruleprec = NULL;
  47   res->dprec = 0;
  48   res->merger = 0;
  49
  50   res->named_ref = NULL;
  51
  52   res->next = NULL;
  53
  54   return res;
  55 }
  56
  57
  58 /*--------------------------------------------.
  59 | Create a list containing TYPE_NAME at LOC.  |
  60 `--------------------------------------------*/
  61
  62 symbol_list *
  63 symbol_list_type_new (uniqstr type_name, location loc)
  64 {
  65   symbol_list *res = xmalloc (sizeof *res);
  66
  67   res->content_type = SYMLIST_TYPE;
  68   res->content.sem_type = xmalloc (sizeof (semantic_type));
  69   res->content.sem_type->tag = type_name;
  70   res->content.sem_type->location = loc;
  71   res->content.sem_type->status = undeclared;
  72
  73   res->location = res->sym_loc = loc;
  74   res->named_ref = NULL;
  75   res->next = NULL;
  76
  77   return res;
  78 }
  79
  80
  81 /*----------------------------------------.
  82 | Create a list containing a <*> at LOC.  |
  83 `----------------------------------------*/
  84
  85 symbol_list *
  86 symbol_list_default_tagged_new (location loc)
  87 {
  88   symbol_list *res = xmalloc (sizeof *res);
  89
  90   res->content_type = SYMLIST_DEFAULT_TAGGED;
  91   res->location = res->sym_loc = loc;
  92   res->named_ref = NULL;
  93   res->next = NULL;
  94
  95   return res;
  96 }
  97
  98
  99 /*---------------------------------------.
 100 | Create a list containing a <> at LOC.  |
 101 `---------------------------------------*/
 102
 103 symbol_list *
 104 symbol_list_default_tagless_new (location loc)
 105 {
 106   symbol_list *res = xmalloc (sizeof *res);
 107
 108   res->content_type = SYMLIST_DEFAULT_TAGLESS;
 109   res->location = res->sym_loc = loc;
 110   res->named_ref = NULL;
 111   res->next = NULL;
 112
 113   return res;
 114 }
 115
 116
 117 /*-----------------------------------------------------------------------.
 118 | Print this list, for which every content_type must be SYMLIST_SYMBOL.  |
 119 `-----------------------------------------------------------------------*/
 120
 121 void
 122 symbol_list_syms_print (const symbol_list *l, FILE *f)
 123 {
 124   for (/* Nothing. */; l && l->content.sym; l = l->next)
 125     {
 126       symbol_print (l->content.sym, f);
 127       fprintf (stderr, l->action_props.is_value_used ? " used" : " unused");
 128       if (l && l->content.sym)
 129         fprintf (f, ", ");
 130     }
 131 }
 132
 133
 134 /*---------------------------.
 135 | Prepend NODE to the LIST.  |
 136 `---------------------------*/
 137
 138 symbol_list *
 139 symbol_list_prepend (symbol_list *list, symbol_list *node)
 140 {
 141   node->next = list;
 142   return node;
 143 }
 144
 145
 146 /*-----------------------------------------------.
 147 | Free the LIST, but not the items it contains.  |
 148 `-----------------------------------------------*/
 149
 150 void
 151 symbol_list_free (symbol_list *list)
 152 {
 153   symbol_list *node, *next;
 154   for (node = list; node; node = next)
 155     {
 156       next = node->next;
 157       named_ref_free (node->named_ref);
 158       free (node);
 159     }
 160 }
 161
 162
 163 /*--------------------.
 164 | Return its length.  |
 165 `--------------------*/
 166
 167 int
 168 symbol_list_length (symbol_list const *l)
 169 {
 170   int res = 0;
 171   for (/* Nothing. */;
 172        l && !(l->content_type == SYMLIST_SYMBOL && l->content.sym == NULL);
 173        l = l->next)
 174     ++res;
 175   return res;
 176 }
 177
 178
 179 /*------------------------------.
 180 | Get item N in symbol list L.  |
 181 `------------------------------*/
 182
 183 symbol_list *
 184 symbol_list_n_get (symbol_list *l, int n)
 185 {
 186   int i;
 187
 188   if (n < 0)
 189     return NULL;
 190
 191   for (i = 0; i < n; ++i)
 192     {
 193       l = l->next;
 194       if (l == NULL
 195           || (l->content_type == SYMLIST_SYMBOL && l->content.sym == NULL))
 196         return NULL;
 197     }
 198
 199   return l;
 200 }
 201
 202
 203 /*--------------------------------------------------------------.
 204 | Get the data type (alternative in the union) of the value for |
 205 | symbol N in symbol list L.                                    |
 206 `--------------------------------------------------------------*/
 207
 208 uniqstr
 209 symbol_list_n_type_name_get (symbol_list *l, location loc, int n)
 210 {
 211   l = symbol_list_n_get (l, n);
 212   if (!l)
 213     {
 214       complain_at (loc, complaint, _("invalid $ value: $%d"), n);
 215       return NULL;
 216     }
 217   aver (l->content_type == SYMLIST_SYMBOL);
 218   return l->content.sym->type_name;
 219 }
 220
 221 bool
 222 symbol_list_null (symbol_list *node)
 223 {
 224   return !node ||
 225     (node->content_type == SYMLIST_SYMBOL && !(node->content.sym));
 226 }
 227
 228 void
 229 symbol_list_code_props_set (symbol_list *node, code_props_type kind,
 230                             location loc, char const *code)
 231 {
 232   code_props cprops;
 233   code_props_symbol_action_init (&cprops, code, loc);
 234   code_props_translate_code (&cprops);
 235   switch (node->content_type)
 236     {
 237       case SYMLIST_SYMBOL:
 238         symbol_code_props_set (node->content.sym, kind, &cprops);
 239         if (node->content.sym->status == undeclared)
 240           node->content.sym->status = used;
 241         break;
 242       case SYMLIST_TYPE:
 243         semantic_type_code_props_set
 244           (semantic_type_get (node->content.sem_type->tag,
 245                               &node->content.sem_type->location),
 246            kind, &cprops);
 247         if (node->content.sem_type->status == undeclared)
 248           node->content.sem_type->status = used;
 249         break;
 250       case SYMLIST_DEFAULT_TAGGED:
 251         default_tagged_code_props_set (kind, &cprops);
 252         break;
 253       case SYMLIST_DEFAULT_TAGLESS:
 254         default_tagless_code_props_set (kind, &cprops);
 255         break;
 256     }
 257 }