Mercurial Mercurial > matiec / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
stage4/generate_c/generate_c_vardecl.cc
changeset 237 cece842c7417
parent 236 c55b02ca2342
child 242 0036357a990f
equal deleted inserted replaced
236:c55b02ca2342 237:cece842c7417 
    77 class generate_c_array_initialization_c: public generate_c_typedecl_c {
 
    77 class generate_c_array_initialization_c: public generate_c_typedecl_c {
 
    78 
    78 
    79   public:
 
    79   public:
 
    80     typedef enum {
 
    80     typedef enum {
 
    81       none_am,
 
    81       none_am,
 
    82       dimensioncount_am,
 
    82       arraysize_am,
 
    83       initializationvalue_am,
 
    83       typedecl_am,
 
    84       arrayassignment_am,
 
    84       initializationvalue_am
 
    85       varlistparse_am
 
       
    86     } arrayinitialization_mode_t;
 
    85     } arrayinitialization_mode_t;
 
    87 
    86 
    88     arrayinitialization_mode_t current_mode;
 
    87     arrayinitialization_mode_t current_mode;
 
    89     
    88     
    90     symbol_c* array_base_type;
 
    89     symbol_c* array_base_type;
 
    91     symbol_c* array_default_value;
 
    90     symbol_c* array_default_value;
 
    92     symbol_c* array_default_initialization;
 
    91     symbol_c* array_default_initialization;
 
    93 
    92 
    94   private:
 
    93   private:
 
    95     int dimension_number;
 
       
    96     int current_dimension;
 
    94     int current_dimension;
 
    97     int array_size;
 
    95     int array_size;
 
    98     int defined_values_count;
 
    96     int defined_values_count;
 
    99     int current_initialization_count;
 
    97     int current_initialization_count;
 
   100 
    98 
   101   public:
 
    99   public:
 
   102     generate_c_array_initialization_c(stage4out_c *s4o_ptr): generate_c_typedecl_c(s4o_ptr) {}
 
   100     generate_c_array_initialization_c(stage4out_c *s4o_ptr): generate_c_typedecl_c(s4o_ptr) {}
 
   103     ~generate_c_array_initialization_c(void) {}
 
   101     ~generate_c_array_initialization_c(void) {}
 
   104 
   102 
   105     void init_array_dimensions(symbol_c *array_specification) {
 
   103     void init_array_size(symbol_c *array_specification) {
 
   106       dimension_number = 0;
 
       
   107       current_dimension = 0;
 
       
   108       array_size = 1;
 
   104       array_size = 1;
 
   109       defined_values_count = 0;
 
   105       defined_values_count = 0;
 
   110       current_initialization_count = 0;
 
   106       current_initialization_count = 0;
 
   111       array_base_type = array_default_value = array_default_initialization = NULL;
 
   107       array_base_type = array_default_value = array_default_initialization = NULL;
 
   112       
   108       
   113       current_mode = dimensioncount_am;
 
   109       current_mode = arraysize_am;
 
   114       array_specification->accept(*this);
 
   110       array_specification->accept(*this);
 
   115     }
 
   111     }
 
   116 
   112 
   117     void init_array(symbol_c *var1_list, symbol_c *array_specification, symbol_c *array_initialization) {
 
   113     void init_array(symbol_c *var1_list, symbol_c *array_specification, symbol_c *array_initialization) {
 
   118       int i;
 
   114       int i;
 
   119       
   115       
   120       init_array_dimensions(array_specification);
 
   116       init_array_size(array_specification);
 
   121       
   117       
   122       current_mode = initializationvalue_am;
 
       
   123       s4o.print("\n");
 
   118       s4o.print("\n");
 
   124       s4o.print(s4o.indent_spaces + "{\n");
 
   119       s4o.print(s4o.indent_spaces + "{\n");
 
   125       s4o.indent_right();
 
   120       s4o.indent_right();
 
   126       s4o.print(s4o.indent_spaces + "int index[");
 
       
   127       print_integer(dimension_number);
 
       
   128       s4o.print("];\n");
 
       
   129       s4o.print(s4o.indent_spaces);
 
   121       s4o.print(s4o.indent_spaces);
 
   130       s4o.print("static const ");
 
   122       s4o.print("static const ");
 
       
   123 
       
   124       current_mode = typedecl_am;
 
   131       array_specification->accept(*this);
 
   125       array_specification->accept(*this);
 
       
   126 
   132       s4o.print(" temp = ");
 
   127       s4o.print(" temp = ");
 
       
   128 
   133       init_array_values(array_initialization);
 
   129       init_array_values(array_initialization);
 
       
   130 
   134       s4o.print(";\n");
 
   131       s4o.print(";\n");
 
   135       
       
   136       current_mode = arrayassignment_am;
 
       
   137       array_specification->accept(*this);
 
       
   138       
       
   139       current_mode = varlistparse_am;
 
       
   140       var1_list->accept(*this);
 
   132       var1_list->accept(*this);
 
   141       
       
   142       current_mode = arrayassignment_am;
 
       
   143       for (i = 0; i < dimension_number; i++) {
 
       
   144         s4o.indent_left();
 
       
   145         s4o.print(s4o.indent_spaces + "}\n");
 
       
   146       }
 
       
   147       s4o.indent_left();
 
   133       s4o.indent_left();
 
   148       s4o.print(s4o.indent_spaces + "}");
 
   134       s4o.print(s4o.indent_spaces + "}");
 
   149     }
 
   135     }
 
   150     
   136     
   151     void init_array_values(symbol_c *array_initialization) {
 
   137     void init_array_values(symbol_c *array_initialization) {
 
   152       s4o.print("{");
 
   138       s4o.print("{{");
 
       
   139 
       
   140       current_mode = initializationvalue_am;
 
   153       array_initialization->accept(*this);
 
   141       array_initialization->accept(*this);
 
       
   142 
   154       if (array_default_initialization != NULL && defined_values_count < array_size)
 
   143       if (array_default_initialization != NULL && defined_values_count < array_size)
 
   155         array_default_initialization->accept(*this);
 
   144         array_default_initialization->accept(*this);
 
   156       if (defined_values_count < array_size) {
 
   145       if (defined_values_count < array_size) {
 
   157         for (int i = defined_values_count; i < array_size; i++) {
 
   146         for (int i = defined_values_count; i < array_size; i++) {
 
   158           if (defined_values_count > 0)
 
   147           if (defined_values_count > 0)
 
   159             s4o.print(",");
 
   148             s4o.print(",");
 
   160           array_default_value->accept(*this);
 
   149           array_default_value->accept(*this);
 
   161           defined_values_count++;
 
   150           defined_values_count++;
 
   162         }
 
   151         }
 
   163       }
 
   152       }
 
   164       s4o.print("}");
 
   153 
       
   154       s4o.print("}}");
 
   165     }
 
   155     }
 
   166     
   156     
   167     void *visit(identifier_c *type_name) {
 
   157     void *visit(identifier_c *type_name) {
 
   168       symbol_c *type_decl;
 
   158       symbol_c *type_decl;
 
   169       switch (current_mode) {
 
   159       switch (current_mode) {
 
   170         case dimensioncount_am:
 
   160         case arraysize_am:
 
   171         case arrayassignment_am:
 
       
   172           /* look up the type declaration... */
 
   161           /* look up the type declaration... */
 
   173           type_decl = type_symtable.find_value(type_name);
 
   162           type_decl = type_symtable.find_value(type_name);
 
   174           if (type_decl == type_symtable.end_value())
 
   163           if (type_decl == type_symtable.end_value())
 
   175             /* Type declaration not found!! */
 
   164             /* Type declaration not found!! */
 
   176             ERROR;
 
   165             ERROR;
 
   190         s4o.print(s4o.indent_spaces);
 
   179         s4o.print(s4o.indent_spaces);
 
   191         s4o.print(SET_VAR);
 
   180         s4o.print(SET_VAR);
 
   192         s4o.print("(");
 
   181         s4o.print("(");
 
   193         print_variable_prefix();
 
   182         print_variable_prefix();
 
   194         symbol->elements[i]->accept(*this);
 
   183         symbol->elements[i]->accept(*this);
 
   195         s4o.print(",temp");
 
   184         s4o.print(", temp);\n");
 
   196         for (j = 0; j < dimension_number; j++) {
 
       
   197           s4o.print("[index[");
 
       
   198           print_integer(j);
 
       
   199           s4o.print("]]");
 
       
   200         }
 
       
   201         s4o.print(",");
 
       
   202         for (j = 0; j < dimension_number; j++) {
 
       
   203           s4o.print("[index[");
 
       
   204           print_integer(j);
 
       
   205           s4o.print("]]");
 
       
   206         }
 
       
   207         s4o.print(");\n");
 
       
   208       }
 
   185       }
 
   209       return NULL;
 
   186       return NULL;
 
   210     }
 
   187     }
 
   211 
   188 
   212 /********************************/
 
   189 /********************************/
 
   215     
   192     
   216     /* array_specification [ASSIGN array_initialization] */
 
   193     /* array_specification [ASSIGN array_initialization] */
 
   217     /* array_initialization may be NULL ! */
 
   194     /* array_initialization may be NULL ! */
 
   218     void *visit(array_spec_init_c *symbol) {
 
   195     void *visit(array_spec_init_c *symbol) {
 
   219       switch (current_mode) {
 
   196       switch (current_mode) {
 
   220         case dimensioncount_am:
 
   197         case arraysize_am:
 
   221           array_default_initialization = symbol->array_initialization;
 
   198           array_default_initialization = symbol->array_initialization;
 
   222           break;
 
   199           break;
 
   223         default:
 
   200         default:
 
   224           break;
 
   201           break;
 
   225       }
 
   202       }
 
   229     
   206     
   230     /* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */
 
   207     /* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */
 
   231     void *visit(array_specification_c *symbol) {
 
   208     void *visit(array_specification_c *symbol) {
 
   232       symbol->array_subrange_list->accept(*this);
 
   209       symbol->array_subrange_list->accept(*this);
 
   233       switch (current_mode) {
 
   210       switch (current_mode) {
 
   234         case dimensioncount_am:
 
   211         case arraysize_am:
 
   235           array_base_type = symbol->non_generic_type_name;
 
   212           array_base_type = symbol->non_generic_type_name;
 
   236           array_default_value = (symbol_c *)symbol->non_generic_type_name->accept(*type_initial_value_c::instance());;
 
   213           array_default_value = (symbol_c *)symbol->non_generic_type_name->accept(*type_initial_value_c::instance());;
 
   237           if (array_default_value == NULL) ERROR;
 
   214           if (array_default_value == NULL) ERROR;
 
   238           break;
 
   215           break;
 
   239         default:
 
   216         default:
 
   244     
   221     
   245     /*  signed_integer DOTDOT signed_integer */
 
   222     /*  signed_integer DOTDOT signed_integer */
 
   246     //SYM_REF2(subrange_c, lower_limit, upper_limit)
 
   223     //SYM_REF2(subrange_c, lower_limit, upper_limit)
 
   247     void *visit(subrange_c *symbol) {
 
   224     void *visit(subrange_c *symbol) {
 
   248       switch (current_mode) {
 
   225       switch (current_mode) {
 
   249         case dimensioncount_am:
 
   226         case arraysize_am:
 
   250           dimension_number++;
 
       
   251           array_size *= extract_integer(symbol->upper_limit) - extract_integer(symbol->lower_limit) + 1;
 
   227           array_size *= extract_integer(symbol->upper_limit) - extract_integer(symbol->lower_limit) + 1;
 
   252           break;
 
       
   253         case arrayassignment_am:
 
       
   254           s4o.print(s4o.indent_spaces + "for (index[");
 
       
   255           print_integer(current_dimension);
 
       
   256           s4o.print("] = 0; index[");
 
       
   257           print_integer(current_dimension);
 
       
   258           s4o.print("] <= ");
 
       
   259           print_integer(extract_integer(symbol->upper_limit) - extract_integer(symbol->lower_limit));
 
       
   260           s4o.print("; index[");
 
       
   261           print_integer(current_dimension);
 
       
   262           s4o.print("]++) {\n");
 
       
   263           s4o.indent_right();
 
       
   264           current_dimension++;
 
       
   265           break;
 
   228           break;
 
   266         default:
 
   229         default:
 
   267           break;
 
   230           break;
 
   268       }
 
   231       }
 
   269       return NULL;
 
   232       return NULL;
 
   517 class generate_c_structure_initialization_c: public generate_c_typedecl_c {
 
   480 class generate_c_structure_initialization_c: public generate_c_typedecl_c {
 
   518 
   481 
   519   public:
 
   482   public:
 
   520     typedef enum {
 
   483     typedef enum {
 
   521       none_sm,
 
   484       none_sm,
 
       
   485       initdefault_sm,
 
   522       typedecl_sm,
 
   486       typedecl_sm,
 
   523       initializationvalue_sm,
 
   487       initializationvalue_sm
 
   524       varlistparse_sm
 
       
   525     } structureinitialization_mode_t;
 
   488     } structureinitialization_mode_t;
 
   526 
   489 
   527     structureinitialization_mode_t current_mode;
 
   490     structureinitialization_mode_t current_mode;
 
   528     
   491     
   529   private:
 
   492   private:
 
   536 
   499 
   537     void init_structure_default(symbol_c *structure_type_name) {
 
   500     void init_structure_default(symbol_c *structure_type_name) {
 
   538       structure_type_decl = NULL;
 
   501       structure_type_decl = NULL;
 
   539       current_element_type = NULL;
 
   502       current_element_type = NULL;
 
   540       
   503       
   541       current_mode = typedecl_sm;
 
   504       current_mode = initdefault_sm;
 
   542       structure_type_name->accept(*this);
 
   505       structure_type_name->accept(*this);
 
   543     }
 
   506     }
 
   544 
   507 
   545     void init_structure(symbol_c *var1_list, symbol_c *structure_type_name, symbol_c *structure_initialization) {
 
   508     void init_structure(symbol_c *var1_list, symbol_c *structure_type_name, symbol_c *structure_initialization) {
 
   546       int i;
 
   509       int i;
 
   547       
   510       
   548       init_structure_default(structure_type_name);
 
   511       init_structure_default(structure_type_name);
 
   549       
   512       
   550       current_mode = initializationvalue_sm;
 
       
   551       s4o.print("\n");
 
   513       s4o.print("\n");
 
   552       s4o.print(s4o.indent_spaces + "{\n");
 
   514       s4o.print(s4o.indent_spaces + "{\n");
 
   553       s4o.indent_right();
 
   515       s4o.indent_right();
 
   554       s4o.print(s4o.indent_spaces);
 
   516       s4o.print(s4o.indent_spaces);
 
   555       s4o.print("static const ");
 
   517       s4o.print("static const ");
 
       
   518 
       
   519       current_mode = typedecl_sm;
 
   556       structure_type_name->accept(*this);
 
   520       structure_type_name->accept(*this);
 
       
   521 
   557       s4o.print(" temp = ");
 
   522       s4o.print(" temp = ");
 
   558       structure_initialization->accept(*this);
 
   523 
       
   524       init_structure_values(structure_initialization);
 
       
   525 
   559       s4o.print(";\n");
 
   526       s4o.print(";\n");
 
   560       
       
   561       current_mode = varlistparse_sm;
 
       
   562       var1_list->accept(*this);
 
   527       var1_list->accept(*this);
 
   563       
       
   564       s4o.indent_left();
 
   528       s4o.indent_left();
 
   565       s4o.print(s4o.indent_spaces + "}");
 
   529       s4o.print(s4o.indent_spaces + "}");
 
       
   530     }
 
       
   531 
       
   532     void init_structure_values(symbol_c *structure_initialization) {
 
       
   533       current_mode = initializationvalue_sm;
 
       
   534       structure_initialization->accept(*this);
 
   566     }
 
   535     }
 
   567 
   536 
   568     void *visit(identifier_c *type_name) {
 
   537     void *visit(identifier_c *type_name) {
 
   569       symbol_c *type_decl;
 
   538       symbol_c *type_decl;
 
   570       switch (current_mode) {
 
   539       switch (current_mode) {
 
   571         case typedecl_sm:
 
   540         case initdefault_sm:
 
   572           /* look up the type declaration... */
 
   541           /* look up the type declaration... */
 
   573           type_decl = type_symtable.find_value(type_name);
 
   542           type_decl = type_symtable.find_value(type_name);
 
   574           if (type_decl == type_symtable.end_value())
 
   543           if (type_decl == type_symtable.end_value())
 
   575             /* Type declaration not found!! */
 
   544             /* Type declaration not found!! */
 
   576             ERROR;
 
   545             ERROR;
 
   603 
   572 
   604     /* helper symbol for structure_declaration */
 
   573     /* helper symbol for structure_declaration */
 
   605     /* structure_element_declaration_list structure_element_declaration ';' */
 
   574     /* structure_element_declaration_list structure_element_declaration ';' */
 
   606     void *visit(structure_element_declaration_list_c *symbol) {
 
   575     void *visit(structure_element_declaration_list_c *symbol) {
 
   607       switch (current_mode) {
 
   576       switch (current_mode) {
 
   608         case typedecl_sm:
 
   577         case initdefault_sm:
 
   609           structure_type_decl = (symbol_c *)symbol;
 
   578           structure_type_decl = (symbol_c *)symbol;
 
   610           break;
 
   579           break;
 
   611         default:
 
   580         default:
 
   612           break;
 
   581           break;
 
   613       } 
   582       } 
   647         
   616         
   648         initialization_analyzer_c initialization_analyzer(element_value);
 
   617         initialization_analyzer_c initialization_analyzer(element_value);
 
   649             
   618             
   650         if (initialization_analyzer.get_initialization_type() == initialization_analyzer_c::struct_it) {
 
   619         if (initialization_analyzer.get_initialization_type() == initialization_analyzer_c::struct_it) {
 
   651           generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
 
   620           generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
 
   652           structure_initialization->set_variable_prefix(get_variable_prefix());
 
       
   653           structure_initialization->init_structure_default(current_element_type);
 
   621           structure_initialization->init_structure_default(current_element_type);
 
   654           structure_initialization->current_mode = generate_c_structure_initialization_c::initializationvalue_sm;
 
   622           structure_initialization->init_structure_values(element_value);
 
   655           element_value->accept(*structure_initialization);
 
       
   656           delete structure_initialization;
 
   623           delete structure_initialization;
 
   657         }
 
   624         }
 
   658         else {
 
   625         else {
 
   659           element_value->accept(*this);
 
   626           element_value->accept(*this);
 
   660         }
 
   627         }
 
   665     
   632     
   666     /* helper symbol for array_initialization */
 
   633     /* helper symbol for array_initialization */
 
   667     /* array_initial_elements_list ',' array_initial_elements */
 
   634     /* array_initial_elements_list ',' array_initial_elements */
 
   668     void *visit(array_initial_elements_list_c *symbol) {
 
   635     void *visit(array_initial_elements_list_c *symbol) {
 
   669       generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
 
   636       generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
 
   670       array_initialization->set_variable_prefix(get_variable_prefix());
 
   637       array_initialization->init_array_size(current_element_type);
 
   671       array_initialization->init_array_dimensions(current_element_type);
 
       
   672       array_initialization->current_mode = generate_c_array_initialization_c::initializationvalue_am;
 
       
   673       array_initialization->init_array_values(symbol);
 
   638       array_initialization->init_array_values(symbol);
 
   674       delete array_initialization;
 
   639       delete array_initialization;
 
   675       return NULL;
 
   640       return NULL;
 
   676     }
 
   641     }
 
   677 
   642 
   680 
   645 
   681 /* helper symbol for array_initialization */
 
   646 /* helper symbol for array_initialization */
 
   682 /* structure_element_initialization_list ',' structure_element_initialization */
 
   647 /* structure_element_initialization_list ',' structure_element_initialization */
 
   683 void *generate_c_array_initialization_c::visit(structure_element_initialization_list_c *symbol) {
 
   648 void *generate_c_array_initialization_c::visit(structure_element_initialization_list_c *symbol) {
 
   684   generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
 
   649   generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
 
   685   structure_initialization->set_variable_prefix(get_variable_prefix());
 
       
   686   structure_initialization->init_structure_default(array_base_type);
 
   650   structure_initialization->init_structure_default(array_base_type);
 
   687   structure_initialization->current_mode = generate_c_structure_initialization_c::initializationvalue_sm;
 
   651   structure_initialization->init_structure_values(symbol);
 
   688   symbol->accept(*structure_initialization);
 
       
   689   delete structure_initialization;
 
   652   delete structure_initialization;
 
   690   return NULL;
 
   653   return NULL;
 
   691 }
 
   654 }
 
   692 
   655 
   693 /***********************************************************************/
 
   656 /***********************************************************************/
 
  1532   TRACE("var_declaration_list_c");
 
  1495   TRACE("var_declaration_list_c");
 
  1533   print_list(symbol);
 
  1496   print_list(symbol);
 
  1534   return NULL;
 
  1497   return NULL;
 
  1535 }
 
  1498 }
 
  1536 
  1499 
  1537 #if 0
 
       
  1538 /*  var1_list ':' array_specification */
 
  1500 /*  var1_list ':' array_specification */
 
  1539 SYM_REF2(array_var_declaration_c, var1_list, array_specification)
 
  1501 //SYM_REF2(array_var_declaration_c, var1_list, array_specification)
 
  1540 #endif
 
  1502 void *visit(array_var_declaration_c *symbol) {
 
       
  1503   TRACE("array_var_declaration_c");
 
       
  1504   /* Please read the comments inside the var1_init_decl_c
 
       
  1505    * visitor, as they apply here too.
 
       
  1506    */
 
       
  1507 
       
  1508   /* Start off by setting the current_var_type_symbol and
 
       
  1509    * current_var_init_symbol private variables...
 
       
  1510    */
 
       
  1511   update_type_init(symbol->array_specification);
 
       
  1512 
       
  1513   /* now to produce the c equivalent... */
 
       
  1514   if (wanted_varformat == constructorinit_vf) {
 
       
  1515     generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
 
       
  1516     array_initialization->set_variable_prefix(get_variable_prefix());
 
       
  1517     array_initialization->init_array(symbol->var1_list, this->current_var_type_symbol, this->current_var_init_symbol);
 
       
  1518     delete array_initialization;
 
       
  1519   }
 
       
  1520   else
 
       
  1521     symbol->var1_list->accept(*this);
 
       
  1522 
       
  1523   /* Values no longer in scope, and therefore no longer used.
 
       
  1524    * Make an effort to keep them set to NULL when not in use
 
       
  1525    * in order to catch bugs as soon as possible...
 
       
  1526    */
 
       
  1527   void_type_init();
 
       
  1528 
       
  1529   return NULL;
 
       
  1530 }
 
  1541 
  1531 
  1542 void *visit(array_initial_elements_list_c *symbol) {
 
  1532 void *visit(array_initial_elements_list_c *symbol) {
 
  1543   if (wanted_varformat == localinit_vf) {
 
  1533   if (wanted_varformat == localinit_vf) {
 
  1544 	generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
 
  1534 	generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
 
  1545 	array_initialization->init_array_dimensions(this->current_var_type_symbol);
 
  1535 	array_initialization->init_array_size(this->current_var_type_symbol);
 
  1546 	array_initialization->current_mode = generate_c_array_initialization_c::initializationvalue_am;
 
       
  1547 	array_initialization->init_array_values(this->current_var_init_symbol);
 
  1536 	array_initialization->init_array_values(this->current_var_init_symbol);
 
  1548 	delete array_initialization;
 
  1537 	delete array_initialization;
 
  1549   }
 
  1538   }
 
  1550   return NULL;
 
  1539   return NULL;
 
  1551 }
 
  1540 }
 
  1584 
  1573 
  1585 void *visit(structure_element_initialization_list_c *symbol) {
 
  1574 void *visit(structure_element_initialization_list_c *symbol) {
 
  1586   if (wanted_varformat == localinit_vf) {
 
  1575   if (wanted_varformat == localinit_vf) {
 
  1587     generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
 
  1576     generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
 
  1588     structure_initialization->init_structure_default(this->current_var_type_symbol);
 
  1577     structure_initialization->init_structure_default(this->current_var_type_symbol);
 
  1589     structure_initialization->current_mode = generate_c_structure_initialization_c::initializationvalue_sm;
 
  1578     structure_initialization->init_structure_values(this->current_var_init_symbol);
 
  1590     this->current_var_init_symbol->accept(*structure_initialization);
 
       
  1591 	delete structure_initialization;
 
  1579 	delete structure_initialization;
 
  1592   }
 
  1580   }
 
  1593   return NULL;
 
  1581   return NULL;
 
  1594 }
 
  1582 }
 
  1595 
  1583
matiec