59     symbol_c* array_base_type;

    61     symbol_c* array_default_initialization;

    74     void init_array_dimensions(symbol_c *array_specification) {

    75       dimension_number = 0;

    76       current_dimension = 0;

    77       array_size = 1;

    78       defined_values_count = 0;

    79       current_initialization_count = 0;

    80       array_base_type = array_default_value = array_default_initialization = NULL;

    81       

    82       current_mode = dimensioncount_am;

    83       array_specification->accept(*this);

    84     }

    85 

   181     /* array_specification [ASSIGN array_initialization] */

   182     /* array_initialization may be NULL ! */

   183     void *visit(array_spec_init_c *symbol) {

   184       switch (current_mode) {

   185         case dimensioncount_am:

   186           array_default_initialization = symbol->array_initialization;

   187           break;

   188         default:

   189           break;

   190       }

   191       symbol->array_specification->accept(*this);

   192       return NULL;

   193     }

   194     

   197       symbol->array_subrange_list->accept(*this);

   202           if (array_default_value == NULL) ERROR;

   308     void *visit(structure_element_initialization_list_c *symbol);

   320 /* given a structure_element_declaration_list_c, iterate 

   321  * through each element, returning the name

   322  * of each element...structure_element_iterator_c

   323  */

   324 class structure_element_iterator_c : public null_visitor_c {

   325   

   326   private:

   327     /* a pointer to the structure_element_declaration_list_c

   328      * currently being analysed.

   329      */

   330     symbol_c *type_decl;

   331     int next_element, element_count;

   332     identifier_c *current_element_name;

   333     symbol_c *current_element_type;

   334     symbol_c *current_element_default_value;

   335     

   336     

   337   public:

   338     /* start off at the first parameter once again... */

   339     void reset(void) {

   340       next_element = element_count = 0;

   341       current_element_name = NULL;

   342       current_element_type = current_element_default_value = NULL;

   343     }

   344     

   345     /* initialise the iterator object.

   346      * We must be given a reference to the function declaration

   347      * that will be analysed...

   348      */

   349     structure_element_iterator_c(symbol_c *type_decl) {

   350       this->type_decl = type_decl;

   351       reset();

   352     }

   353     

   354     /* Skip to the next element. After object creation,

   355      * the object references on 

   356      * element _before_ the first, so

   357      * this function must be called once to get the object to

   358      * reference the first element...

   359      *

   360      * Returns the element's name!

   361      */

   362     identifier_c *next(void) {

   363       void *res;

   364       identifier_c *identifier;

   365       element_count = 0;

   366       next_element++;

   367       res = type_decl->accept(*this);

   368       if (res != NULL) {

   369         symbol_c *sym = (symbol_c *)res;

   370         identifier = dynamic_cast<identifier_c *>(sym);

   371         if (identifier == NULL)

   372           ERROR;

   373       }

   374       else

   375         return NULL;

   376       

   377       current_element_name = identifier;

   378       return current_element_name;

   379     }

   380     

   381     /* Returns the currently referenced element's default value,

   382      * or NULL if none is specified in the structure declaration itself.

   383      */

   384     symbol_c *default_value(void) {

   385       return current_element_default_value;

   386     }

   387 

   388     /* Returns the currently referenced element's type name. */

   389     symbol_c *element_type(void) {

   390       return current_element_type;

   391     }

   392 

   393 /********************************/

   394 /* B 1.3.3 - Derived data types */

   395 /********************************/

   396 

   397     /* helper symbol for structure_declaration */

   398     /* structure_element_declaration_list structure_element_declaration ';' */

   399     void *visit(structure_element_declaration_list_c *symbol) {

   400       void *res;

   401       for (int i = 0; i < symbol->n; i++) {

   402         res = symbol->elements[i]->accept(*this);

   403         if (res != NULL)

   404           return res;

   405       }

   406       return NULL;

   407     }

   408 

   409     /*  structure_element_name ':' *_spec_init */

   410     void *visit(structure_element_declaration_c *symbol) {

   411       element_count++;

   412       if (next_element == element_count) {

   413         current_element_default_value = spec_init_sperator_c::get_init(symbol->spec_init);

   414         current_element_type = spec_init_sperator_c::get_spec(symbol->spec_init);

   415         return symbol->structure_element_name;

   416       }

   417       /* not yet the desired element... */

   418       return NULL;

   419     }

   420 

   421 };

   422 

   423 /*

   424  * Structure init element iterator.

   425  * It will search through the elements of a structure initialization

   426  */

   427 class structure_init_element_iterator_c : public null_visitor_c {

   428   private:

   429     /* a pointer to the structure initialization

   430      * currently being analysed.

   431      */

   432     symbol_c *structure_initialization;

   433     identifier_c *search_element_name;

   434     

   435   public:

   436     /* initialise the iterator object.

   437      * We must be given a reference to the structure initialization

   438      * that will be analysed...

   439      */

   440     structure_init_element_iterator_c(symbol_c *structure_initialization) {

   441       this->structure_initialization = structure_initialization;

   442       search_element_name = NULL;

   443     }

   444     

   445     /* Search for the value passed to the element named <element_name>...  */

   446     symbol_c *search(symbol_c *element_name) {

   447       if (NULL == element_name) ERROR;

   448       search_element_name = dynamic_cast<identifier_c *>(element_name);

   449       if (NULL == search_element_name) ERROR;

   450       void *res = structure_initialization->accept(*this);

   451       return (symbol_c *)res;

   452     }

   453     

   454     /* helper symbol for structure_initialization */

   455     /* structure_element_initialization_list ',' structure_element_initialization */

   456     void *visit(structure_element_initialization_list_c *symbol) {

   457       void *res;

   458       for (int i = 0; i < symbol->n; i++) {

   459         res = symbol->elements[i]->accept(*this);

   460         if (res != NULL)

   461           return res;

   462       }

   463       return NULL;

   464     }

   465     

   466     /*  structure_element_name ASSIGN value */

   467     void *visit(structure_element_initialization_c *symbol) {

   468       identifier_c *element_name = dynamic_cast<identifier_c *>(symbol->structure_element_name);

   469       

   470       if (element_name == NULL) ERROR;

   471       

   472       if (strcasecmp(search_element_name->value, element_name->value) == 0)

   473         /* FOUND! This is the same element!! */

   474         return (void *)symbol->value;

   475       return NULL;

   476     }

   477 };

   478 

   479 class generate_c_structure_initialization_c: public generate_c_typedecl_c {

   480 

   481   public:

   482     typedef enum {

   483       none_sm,

   484       typedecl_sm,

   485       initializationvalue_sm,

   486       varlistparse_sm

   487     } structureinitialization_mode_t;

   488 

   489     structureinitialization_mode_t current_mode;

   490     

   491   private:

   492     symbol_c* structure_type_decl;

   493     symbol_c* current_element_type;

   494 

   495   public:

   496     generate_c_structure_initialization_c(stage4out_c *s4o_ptr): generate_c_typedecl_c(s4o_ptr) {}

   497     ~generate_c_structure_initialization_c(void) {}

   498 

   499     void init_structure_default(symbol_c *structure_type_name) {

   500       structure_type_decl = NULL;

   501       current_element_type = NULL;

   502       

   503       current_mode = typedecl_sm;

   504       structure_type_name->accept(*this);

   505     }

   506 

   507     void init_structure(symbol_c *var1_list, symbol_c *structure_type_name, symbol_c *structure_initialization) {

   508       int i;

   509       

   510       init_structure_default(structure_type_name);

   511       

   512       current_mode = initializationvalue_sm;

   513       s4o.print("\n");

   514       s4o.print(s4o.indent_spaces + "{\n");

   515       s4o.indent_right();

   516       s4o.print(s4o.indent_spaces);

   517       structure_type_name->accept(*this);

   518       s4o.print(" temp = ");

   519       structure_initialization->accept(*this);

   520       s4o.print(";\n");

   521       

   522       current_mode = varlistparse_sm;

   523       var1_list->accept(*this);

   524       

   525       s4o.indent_left();

   526       s4o.print(s4o.indent_spaces + "}");

   527     }

   528 

   529     void *visit(identifier_c *type_name) {

   530       symbol_c *type_decl;

   531       switch (current_mode) {

   532         case typedecl_sm:

   533           /* look up the type declaration... */

   534           type_decl = type_symtable.find_value(type_name);

   535           if (type_decl == type_symtable.end_value())

   536             /* Type declaration not found!! */

   537             ERROR;

   538           type_decl->accept(*this);

   539           break;

   540         default:

   541           print_token(type_name);

   542           break;

   543       }

   544       return NULL;

   545     }

   546     

   547     void *visit(var1_list_c *symbol) {

   548       int i, j;

   549       

   550       for (i = 0; i < symbol->n; i++) {

   551         s4o.print(s4o.indent_spaces);

   552         print_variable_prefix();

   553         symbol->elements[i]->accept(*this);

   554         s4o.print(" = temp;\n");

   555       }

   556       return NULL;

   557     }

   558 

   559 /********************************/

   560 /* B 1.3.3 - Derived data types */

   561 /********************************/

   562 

   563     /* helper symbol for structure_declaration */

   564     /* structure_element_declaration_list structure_element_declaration ';' */

   565     void *visit(structure_element_declaration_list_c *symbol) {

   566       switch (current_mode) {

   567         case typedecl_sm:

   568           structure_type_decl = (symbol_c *)symbol;

   569           break;

   570         default:

   571           break;

   572       } 

   573       return NULL;

   574     }

   575 

   576     /* helper symbol for structure_initialization */

   577     /* structure_element_initialization_list ',' structure_element_initialization */

   578     void *visit(structure_element_initialization_list_c *symbol) {

   579       s4o.print("{");

   580       structure_element_iterator_c structure_iterator(structure_type_decl);

   581       

   582       identifier_c *element_name;

   583       structure_init_element_iterator_c structure_init_element_iterator(symbol);

   584       for(int i = 1; (element_name = structure_iterator.next()) != NULL; i++) {

   585         if (i > 1)

   586           s4o.print(", ");

   587         

   588         /* Get the value from an initialization */

   589         symbol_c *element_value = structure_init_element_iterator.search(element_name);

   590         

   591         if (element_value == NULL) {

   592           /* No value given for parameter, so we must use the default... */

   593           /* First check whether default value specified in function declaration...*/

   594           element_value = structure_iterator.default_value();

   595           current_element_type = structure_iterator.element_type();

   596         }

   597         

   598         if (element_value == NULL) {

   599           if (current_element_type == NULL) ERROR;

   600           

   601           /* If not, get the default value of this variable's type */

   602           element_value = (symbol_c *)current_element_type->accept(*type_initial_value_c::instance());

   603         }

   604         

   605         if (element_value == NULL) ERROR;

   606         

   607         element_value->accept(*this);

   608       }

   609       s4o.print("}");

   610       return NULL;

   611     }

   612 

   613     /* helper symbol for array_initialization */

   614     /* array_initial_elements_list ',' array_initial_elements */

   615     void *visit(array_initial_elements_list_c *symbol) {

   616       generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);

   617       array_initialization->set_variable_prefix(get_variable_prefix());

   618       array_initialization->init_array_dimensions(current_element_type);

   619       array_initialization->current_mode = generate_c_array_initialization_c::initializationvalue_am;

   620       array_initialization->init_array_values(symbol);

   621       delete array_initialization;

   622       return NULL;

   623     }

   624 

   625 };

   626 

   627 

   628 /* helper symbol for array_initialization */

   629 /* structure_element_initialization_list ',' structure_element_initialization */

   630 void *generate_c_array_initialization_c::visit(structure_element_initialization_list_c *symbol) {

   631   generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);

   632   structure_initialization->set_variable_prefix(get_variable_prefix());

   633   structure_initialization->init_structure_default(array_base_type);

   634   structure_initialization->current_mode = generate_c_structure_initialization_c::initializationvalue_sm;

   635   symbol->accept(*structure_initialization);

   636   delete structure_initialization;

   637   return NULL;

   638 }

   639 

   640 /***********************************************************************/

   641 /***********************************************************************/

   642 /***********************************************************************/

   643 /***********************************************************************/

   644 /***********************************************************************/

   645 /***********************************************************************/

   646 /***********************************************************************/

   647 /***********************************************************************/