src/symlist.c

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