mpc/structures/identifier.c

   1 /********************************************************************
   2
   3         identifier.c - handling identifier descriptions
   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 "unit.h"
  20 #include "../util/memory.h"
  21
  22 #include <string.h>
  23 #include <stdlib.h>
  24
  25 extern FILE* symbols_file;
  26
  27 /*
  28         Creates an empty identifier
  29 */
  30
  31 identifier *identifier_create()
  32 {
  33         identifier *new_identifier;
  34         new_identifier = (identifier*) mem_alloc(sizeof(identifier));
  35
  36         if (new_identifier == NULL)
  37                 die(1);
  38
  39         new_identifier->identifier_class = none;
  40
  41         new_identifier->standard_function = 0;
  42
  43         new_identifier->variables = NULL;
  44
  45         new_identifier->forward_declaration = 0;
  46
  47         new_identifier->unit_block = NULL;
  48
  49         new_identifier->unit_function = 0;
  50         new_identifier->container_unit = NULL;
  51
  52         return new_identifier;
  53 }
  54
  55
  56 /*
  57         Deletes an identifier
  58 */
  59 void identifier_destroy(identifier *item)
  60 {
  61         switch (item->identifier_class)
  62         {
  63         case constant_name:
  64                 {
  65                         if (item->constant_type->type_class == string_type)
  66                                 string_destroy(item->constant_string_value);
  67                         type_destroy(item->constant_type);
  68                         break;
  69                 }
  70
  71         case variable_name:
  72                 {
  73                         if (item->variable_type != NULL)
  74                                 type_destroy(item->variable_type);
  75                         break;
  76                 }
  77
  78         case type_name:
  79                 {
  80                         type_destroy(item->defined_type);
  81                         break;
  82                 }
  83
  84         case procedure_name:
  85                 {
  86                         type_list_destroy(item->parameters);
  87                         if (item->variables != NULL)
  88                                 type_list_destroy(item->variables);
  89                         break;
  90                 }
  91
  92         case function_name:
  93                 {
  94                         type_destroy(item->return_type);
  95                         type_list_destroy(item->parameters);
  96                         if (item->variables != NULL)
  97                                 type_list_destroy(item->variables);
  98                         break;
  99                 }
 100
 101         case parameter_name:
 102                 {
 103                         type_destroy(item->parameter_type);
 104                         break;
 105                 }
 106
 107         case unit_name:
 108                 {
 109                         unit_destroy(item->unit_block);
 110                         break;
 111                 }
 112         }
 113
 114         mem_free(item);
 115 }
 116
 117 /*
 118         Create a copy of a given identifier
 119 */
 120 identifier *identifier_duplicate(identifier *item)
 121 {
 122         identifier *new_identifier;
 123         new_identifier = (identifier*) mem_alloc(sizeof(identifier));
 124
 125         if (new_identifier == NULL)
 126                 die(1);
 127
 128         new_identifier->identifier_class = item->identifier_class;
 129         new_identifier->unit_function = item->unit_function;
 130
 131         switch(new_identifier->identifier_class)
 132         {
 133         case constant_name:
 134                 {
 135                         new_identifier->constant_type = type_duplicate(item->constant_type);
 136                         switch(item->constant_type->type_class)
 137                         {
 138                         case integer_type:
 139                                 {
 140                                         new_identifier->constant_int_value = item->constant_int_value;
 141                                         break;
 142                                 }
 143                         case char_type:
 144                                 {
 145                                         new_identifier->constant_int_value = item->constant_int_value;
 146                                         break;
 147                                 }
 148                         case string_type:
 149                                 {
 150                                         new_identifier->constant_string_value = string_duplicate(item->constant_string_value);
 151                                         break;
 152                                 }
 153                         case boolean_type:
 154                                 {
 155                                         new_identifier->constant_int_value = item->constant_int_value;
 156                                         break;
 157                                 }
 158                         case real_type:
 159                                 {
 160                                         new_identifier->constant_real_value = item->constant_real_value;
 161                                         break;
 162                                 }
 163                         case command_type:
 164                         case record_store_type:
 165                         case http_type:
 166                         case image_type:
 167                         case stream_type:
 168                         case alert_type:
 169                                 {
 170                                         break;
 171                                 }
 172                         default:
 173                                 {
 174                                         die(11);
 175                                 }
 176                         }
 177                         break;
 178                 }
 179
 180         case variable_name:
 181                 {
 182                         new_identifier->variable_type = type_duplicate(item->variable_type);
 183                         new_identifier->variable_index = item->variable_index;
 184                         break;
 185                 }
 186
 187         case type_name:
 188                 {
 189                         new_identifier->defined_type = type_duplicate(item->defined_type);
 190                         break;
 191                 }
 192
 193         case procedure_name:
 194                 {
 195                         new_identifier->parameters = type_list_duplicate(item->parameters);
 196                         new_identifier->forward_declaration = item->forward_declaration;
 197                         new_identifier->standard_function = item->standard_function;
 198                         new_identifier->variables = type_list_duplicate(item->variables);
 199                         if (item->container_unit != NULL)
 200                                 new_identifier->container_unit = unit_duplicate(item->container_unit);
 201                         else
 202                                 new_identifier->container_unit = NULL;
 203                         break;
 204                 }
 205
 206         case function_name:
 207                 {
 208                         new_identifier->parameters = type_list_duplicate(item->parameters);
 209                         new_identifier->return_type = type_duplicate(item->return_type);
 210                         new_identifier->forward_declaration = item->forward_declaration;
 211                         new_identifier->standard_function = item->standard_function;
 212                         new_identifier->variables = type_list_duplicate(item->variables);
 213                         break;
 214                 }
 215
 216         case parameter_name:
 217                 {
 218                         new_identifier->parameter_type = type_duplicate(item->parameter_type);
 219                         new_identifier->is_parameter_variable = item->is_parameter_variable;
 220                         new_identifier->parameter_index = item->parameter_index;
 221                         break;
 222                 }
 223
 224         case unit_name:
 225                 {
 226                         new_identifier->unit_block = unit_duplicate(item->unit_block);
 227                         break;
 228                 }
 229
 230         }
 231
 232         if (item->container_unit != NULL)
 233                 new_identifier->container_unit = unit_duplicate(item->container_unit);
 234         else
 235                 new_identifier->container_unit = NULL;
 236
 237         if (item->unit_block != NULL)
 238                 new_identifier->unit_block = unit_duplicate(item->unit_block);
 239         else
 240                 new_identifier->unit_block = NULL;
 241
 242         return new_identifier;
 243 }
 244
 245 void bsf_write_integer_constant(long int value, char* name)
 246 {
 247         char tag = 1;
 248         char type = 1;
 249         fwrite(&tag, 1, 1, symbols_file);
 250         bsf_write_STRING(name);
 251         fwrite(&type, 1, 1, symbols_file);
 252         fwrite(&value, sizeof(long int), 1, symbols_file);
 253 }
 254
 255 void bsf_write_real_constant(float value, char* name)
 256 {
 257         char tag = 1;
 258         char type = 2;
 259         fwrite(&tag, 1, 1, symbols_file);
 260         bsf_write_STRING(name);
 261         fwrite(&type, 1, 1, symbols_file);
 262         fwrite(&value, sizeof(float), 1, symbols_file);
 263 }
 264
 265 void bsf_write_boolean_constant(char value, char* name)
 266 {
 267         char tag = 1;
 268         char type = 3;
 269         fwrite(&tag, 1, 1, symbols_file);
 270         bsf_write_STRING(name);
 271         fwrite(&type, 1, 1, symbols_file);
 272         fwrite(&value, sizeof(char), 1, symbols_file);
 273 }
 274
 275 void bsf_write_char_constant(char value, char* name)
 276 {
 277         char tag = 1;
 278         char type = 4;
 279         fwrite(&tag, 1, 1, symbols_file);
 280         bsf_write_STRING(name);
 281         fwrite(&type, 1, 1, symbols_file);
 282         fwrite(&value, sizeof(char), 1, symbols_file);
 283 }
 284
 285 void bsf_write_string_constant(string* value, char* name)
 286 {
 287         char tag = 1;
 288         char type = 5;
 289         fwrite(&tag, 1, 1, symbols_file);
 290         bsf_write_STRING(name);
 291         fwrite(&type, 1, 1, symbols_file);
 292
 293         bsf_write_STRING(string_get_cstr(value));
 294 }
 295
 296 void bsf_write_variables(string_list* names, type* var_type)
 297 {
 298         string_list *it = names;
 299
 300         while ((it != NULL) && (it->data != NULL))
 301         {
 302                 char tag = 2;
 303                 fwrite(&tag, 1, 1, symbols_file);
 304                 bsf_write_STRING(string_get_cstr(it->data));
 305                 bsf_write_TYPE(var_type);
 306                 it = it->next;
 307         }
 308 }
 309
 310 void bsf_write_type(string* type_name, type* type_type)
 311 {
 312         char tag = 3;
 313         fwrite(&tag, 1, 1, symbols_file);
 314         bsf_write_STRING(string_get_cstr(type_name));
 315         bsf_write_TYPE(type_type);
 316 }
 317
 318 void bsf_write_procedure(string* name, type_list* parameters)
 319 {
 320         type_list *it;
 321         char params_count = 0;
 322
 323         char tag = 4;
 324         fwrite(&tag, 1, 1, symbols_file);
 325         bsf_write_STRING(string_get_cstr(name));
 326
 327         params_count = type_list_length(parameters);
 328         fwrite(&params_count, 1, 1, symbols_file);
 329
 330         it = parameters;
 331
 332         while ((it != NULL) && (it->data != NULL))
 333         {
 334                 bsf_write_TYPE(it->data);
 335                 it = it->next;
 336         }
 337 }
 338
 339 void bsf_write_function(string* name, type_list* parameters, type* return_type)
 340 {
 341         type_list *it;
 342         char params_count = 0;
 343
 344         char tag = 5;
 345         fwrite(&tag, 1, 1, symbols_file);
 346         bsf_write_STRING(string_get_cstr(name));
 347
 348         bsf_write_TYPE(return_type);
 349
 350         params_count = type_list_length(parameters);
 351         fwrite(&params_count, 1, 1, symbols_file);
 352
 353         it = parameters;
 354
 355         while ((it != NULL) && (it->data != NULL))
 356         {
 357                 bsf_write_TYPE(it->data);
 358                 it = it->next;
 359         }
 360 }
 361
 362 void bsf_write_STRING(char* value)
 363 {
 364         char len = strlen(value);
 365         lowercase(value);
 366         fwrite(&len, 1, 1, symbols_file);
 367         fwrite(value, 1, len, symbols_file);
 368 }
 369
 370 string* bsf_read_STRING(FILE* file)
 371 {
 372         char length;
 373         char *buffer;
 374         string* string_value;
 375
 376         fread(&length, 1, 1, file);
 377         buffer = (char*) malloc(length + 5);
 378         fread(buffer, 1, length, file);
 379         buffer[length] = '\0';
 380         string_value = string_from_cstr(buffer);
 381         free(buffer);
 382
 383         return string_value;
 384 }
 385
 386 void bsf_write_TYPE(type* type_desc)
 387 {
 388         // j-a-s-d
 389         #ifdef __GNUC__
 390         fwrite((char *)&type_desc->type_class, 1, 1, symbols_file);
 391         #else
 392         fwrite(&(char)type_desc->type_class, 1, 1, symbols_file);
 393         #endif
 394
 395         if (type_desc->type_class == array_type)
 396         {
 397                 char dimensions;
 398                 type_list *it;
 399
 400                 bsf_write_TYPE(type_desc->element_type);
 401
 402                 dimensions = type_list_length(type_desc->dimensions_list);
 403                 fwrite(&dimensions, 1, 1, symbols_file);
 404
 405                 it = type_desc->dimensions_list;
 406
 407                 while ((it != NULL) && (it->data != NULL))
 408                 {
 409                         bsf_write_TYPE(it->data);
 410                         it = it->next;
 411                 }
 412         }
 413
 414         if (type_desc->type_class == record_type)
 415         {
 416                 char elements;
 417                 string_list *name_it;
 418                 type_list *type_it;
 419
 420                 elements = string_list_length(type_desc->elements_name_list);
 421                 fwrite(&elements, 1, 1, symbols_file);
 422
 423                 name_it = type_desc->elements_name_list;
 424                 type_it = type_desc->elements_type_list;
 425
 426                 while ((name_it != NULL) && (name_it->data != NULL))
 427                 {
 428                         bsf_write_STRING(string_get_cstr(name_it->data));
 429                         bsf_write_TYPE(type_it->data);
 430
 431                         name_it = name_it->next;
 432                         type_it = type_it->next;
 433                 }
 434
 435                 fwrite(&type_desc->unique_record_ID, 4, 1, symbols_file);
 436         }
 437
 438         if (type_desc->type_class == interval_type)
 439         {
 440         // j-a-s-d
 441         #ifdef __GNUC__
 442         fwrite((char *)&type_desc->interval_base_type, 1, 1, symbols_file);
 443         #else
 444         fwrite(&(char)type_desc->interval_base_type, 1, 1, symbols_file);
 445         #endif
 446                 fwrite(&type_desc->first_element, 4, 1, symbols_file);
 447                 fwrite(&type_desc->last_element, 4, 1, symbols_file);
 448         }
 449 }
 450
 451 type* bsf_read_TYPE(FILE* symbol_file)
 452 {
 453         char type_class;
 454
 455         type* result_type = type_create();
 456
 457         fread(&type_class, 1, 1, symbol_file);
 458         result_type->type_class = (enum en_type_class)type_class;
 459
 460         if (result_type->type_class == array_type)
 461         {
 462                 char dimensions;
 463
 464                 result_type->element_type = bsf_read_TYPE(symbol_file);
 465                 fread(&dimensions, 1, 1, symbol_file);
 466
 467                 result_type->dimensions_list = type_list_create();
 468
 469                 while (dimensions > 0)
 470                 {
 471                         type_list_append(result_type->dimensions_list, bsf_read_TYPE(symbol_file));
 472                         dimensions --;
 473                 }
 474         }
 475
 476         if (result_type->type_class == record_type)
 477         {
 478                 char elements;
 479                 fread(&elements, 1, 1, symbol_file);
 480
 481                 result_type->elements_name_list = string_list_create();
 482                 result_type->elements_type_list = type_list_create();
 483
 484                 while (elements > 0)
 485                 {
 486                         string_list_append(result_type->elements_name_list, bsf_read_STRING(symbol_file));
 487                         type_list_append(result_type->elements_type_list, bsf_read_TYPE(symbol_file));
 488                         elements --;
 489                 }
 490
 491                 fread(&result_type->unique_record_ID, sizeof(int), 1, symbol_file);
 492         }
 493
 494         if (result_type->type_class == interval_type)
 495         {
 496                 char base_type_class;
 497                 fread(&base_type_class, 1, 1, symbol_file);
 498
 499                 result_type->interval_base_type = (enum en_type_class)base_type_class;
 500
 501                 fread(&result_type->first_element, sizeof(long int), 1, symbol_file);
 502                 fread(&result_type->last_element, sizeof(long int), 1, symbol_file);
 503         }
 504
 505         return result_type;
 506 }