MPC.3.5.LINUX/structures/type_list.c

   1 /********************************************************************
   2
   3         type_list.c - function for handling type lists
   4
   5   Niksa Orlic, 2004-04-28
   6
   7 ********************************************************************/
   8
   9 #include "../util/strings.h"
  10 #include "../util/error.h"
  11 //#include "../util/message.h"
  12 #include "type_list.h"
  13 #include "string_list.h"
  14 #include "type.h"
  15 #include "identifier.h"
  16 #include "name_table.h"
  17 #include "../classgen/bytecode.h"
  18 #include "block.h"
  19 #include "../util/memory.h"
  20
  21 #include <stdlib.h>
  22
  23 /*
  24         Create a new empty list
  25 */
  26 type_list *type_list_create()
  27 {
  28         type_list *new_list = (type_list*) mem_alloc(sizeof(type_list));
  29
  30         if (new_list == NULL)
  31                 die(1);
  32
  33         new_list->data = NULL;
  34         new_list->next = NULL;
  35
  36         return new_list;
  37 }
  38
  39
  40 /*
  41         Delete the list with all associated data
  42 */
  43 void type_list_destroy(type_list* item)
  44 {
  45         type_list *it, *next;
  46         it = item;
  47
  48         while (it != NULL)
  49         {
  50                 next = it->next;
  51
  52                 if (it->data != NULL)
  53                         mem_free(it->data);
  54
  55                 mem_free (it);
  56
  57                 it = next;
  58         }
  59
  60 }
  61
  62 /*
  63         Creates a copy of the list, the data
  64         values are also copied
  65 */
  66 type_list *type_list_duplicate(type_list *item)
  67 {
  68         type_list *new_list;
  69
  70         if (item == NULL)
  71                 return NULL;
  72
  73         new_list = type_list_create();
  74
  75         if ((item == NULL) ||(item->data == NULL))
  76                 return new_list;
  77
  78         do
  79         {
  80                 type_list_append(new_list, item->data);
  81                 item = item->next;
  82         } while (item != NULL);
  83
  84         return new_list;
  85 }
  86
  87
  88 /*
  89         Add an element into the list, the data is
  90         copied.
  91 */
  92 void type_list_append(type_list *item, struct type_struct *data)
  93 {
  94         type_list *new_element;
  95
  96         if (item->data == NULL)
  97                 item->data = type_duplicate(data);
  98         else
  99         {
 100                 new_element = (type_list*) mem_alloc(sizeof(type_list));
 101
 102                 if (new_element == NULL)
 103                         die(1);
 104
 105                 new_element->data = type_duplicate(data);
 106                 new_element->next = NULL;
 107
 108                 /* move to the end of the list */
 109                 while (item->next != NULL)
 110                         item = item->next;
 111
 112                 item->next = new_element;
 113         }
 114 }
 115
 116
 117 /*
 118         Returns the number of elements in the list
 119 */
 120 int type_list_length(type_list *item)
 121 {
 122         int counter = 0;
 123
 124         if (item->data == NULL)
 125                 return counter;
 126
 127         do
 128         {
 129                 item = item->next;
 130                 counter ++;
 131         } while (item != NULL);
 132
 133         return counter;
 134 }
 135
 136
 137 /*
 138         Returns the index (starting with one) of the first
 139         item in the list1 different than the parameetr in the list2,
 140         0 if the lists are equal, or -1 if the list1 is shorter than
 141         the list2 and all elements in the list1 correspond to the first
 142         n elements in the list2.
 143 */
 144 int type_list_different_parameter(type_list *list1, type_list *list2)
 145 {
 146         int counter = 1;
 147
 148         while (list1 != NULL)
 149         {
 150                 if ((list2 == NULL)
 151                         || (list1->data == NULL)
 152                         || (list2->data == NULL)
 153                         || (!type_equal(list1->data, list2->data)))
 154                 {
 155                         if ((list2 != NULL)
 156                                 && (list1->data == NULL)
 157                                 && (list2->data == NULL))
 158                                 return 0;
 159
 160                         return counter;
 161                 }
 162
 163                 counter ++;
 164                 list1 = list1->next;
 165                 list2 = list2->next;
 166         }
 167
 168         if (list2 != NULL)
 169                 return -1;
 170
 171         return 0;
 172 }
 173
 174 /*
 175         Same as the previous function, except that if the list1 element
 176         can be casted into list2 element, it is OK !!!
 177 */
 178 int type_list_different_parameter_cast(type_list *list1, type_list *list2)
 179 {
 180         int counter = 1;
 181
 182         while (list1 != NULL)
 183         {
 184                 if ((list2 == NULL)
 185                         || (list1->data == NULL)
 186                         || (list2->data == NULL)
 187                         || (type_equal_cast(list1->data, list2->data) == 0)
 188                         || (type_equal_cast(list1->data, list2->data) == 2))
 189                 {
 190                         if ((list2 != NULL)
 191                                 && (list1->data == NULL)
 192                                 && (list2->data == NULL))
 193                                 return 0;
 194
 195                         return counter;
 196                 }
 197
 198                 counter ++;
 199                 list1 = list1->next;
 200                 list2 = list2->next;
 201         }
 202
 203         if (list2 != NULL)
 204                 return -1;
 205
 206         return 0;
 207 }
 208
 209 /*
 210         Same as the above, but compares interval base types against the types;
 211         this is used when checking array dimensions
 212 */
 213 int type_list_different_parameter_array(type_list *real_types, type_list *interval_types)
 214 {
 215         int counter = 1;
 216
 217         while (real_types != NULL)
 218         {
 219                 if ((interval_types == NULL)
 220                         || (real_types->data == NULL)
 221                         || (interval_types->data == NULL)
 222                         || (real_types->data->type_class != interval_types->data->interval_base_type))
 223                 {
 224                         return counter;
 225                 }
 226
 227                 counter ++;
 228                 real_types = real_types->next;
 229                 interval_types = interval_types->next;
 230         }
 231
 232         if (interval_types != NULL)
 233                 return -1;
 234
 235         return 0;
 236 }