matiec: comparison stage4/generate_c/generate_c

equal deleted inserted replaced

-:566414d7ba1f
+:477393b00f95
 }
 };
 // Does this class really need to derive from generate_c_typedecl_c ???
-class generate_c_array_initialization_c: public generate_c_typedecl_c {
+class generate_c_array_initialization_c: public generate_c_base_and_typeid_c {
 public:
 typedef enum {
 none_am,
 arraysize_am,
 unsigned long long int array_size;
 unsigned long long int defined_values_count;
 unsigned long long int current_initialization_count;
 public:
-generate_c_array_initialization_c(stage4out_c *s4o_ptr): generate_c_typedecl_c(s4o_ptr) {}
+generate_c_array_initialization_c(stage4out_c *s4o_ptr): generate_c_base_and_typeid_c(s4o_ptr) {}
 ~generate_c_array_initialization_c(void) {}
 void init_array_size(symbol_c *array_specification) {
 array_size = 1;
 defined_values_count = 0;
 symbol_c *type_decl;
 switch (current_mode) {
 case arraysize_am:
 /* look up the type declaration... */
 type_decl = type_symtable.find_value(type_name);
-if (type_decl == type_symtable.end_value())
+if (type_decl == type_symtable.end_value())   ERROR;  // Type declaration not found!!
-/* Type declaration not found!! */
-ERROR;
 type_decl->accept(*this);
 break;
 default:
 print_token(type_name);
 break;
 return (void *)symbol->value;
 return NULL;
 }
 };
-class generate_c_structure_initialization_c: public generate_c_typedecl_c {
+class generate_c_structure_initialization_c: public generate_c_base_and_typeid_c {
 public:
 typedef enum {
 none_sm,
 initdefault_sm,
 symbol_c* structure_type_decl;
 symbol_c* current_element_type;
 symbol_c* current_element_default_value;
 public:
-generate_c_structure_initialization_c(stage4out_c *s4o_ptr): generate_c_typedecl_c(s4o_ptr) {}
+generate_c_structure_initialization_c(stage4out_c *s4o_ptr): generate_c_base_and_typeid_c(s4o_ptr) {}
 ~generate_c_structure_initialization_c(void) {}
 void init_structure_default(symbol_c *structure_type_name) {
 structure_type_decl = NULL;
 current_element_type = NULL;
 current_mode = initializationvalue_sm;
 structure_initialization->accept(*this);
 }
 void *visit(identifier_c *type_name) {
+symbol_c *type_decl;
+switch (current_mode) {
+case initdefault_sm:
+/* look up the type declaration... */
+type_decl = type_symtable.find_value(type_name);
+if (type_decl == type_symtable.end_value())
+/* Type declaration not found!! */
+ERROR;
+type_decl->accept(*this);
+break;
+default:
+print_token(type_name);
+break;
+}
+return NULL;
+}
+void *visit(derived_datatype_identifier_c *type_name) {
 symbol_c *type_decl;
 switch (current_mode) {
 case initdefault_sm:
 /* look up the type declaration... */
 type_decl = type_symtable.find_value(type_name);
 /***********************************************************************/
 /***********************************************************************/
-class generate_c_vardecl_c: protected generate_c_base_c {
+class generate_c_vardecl_c: protected generate_c_base_and_typeid_c {
 /* A Helper class to the main class... */
 /* print a string, except the first time it is called */
 /* used to print the separator "," before each variable
 * declaration, except the first...
 symbol_c *current_var_type_symbol;
 symbol_c *current_var_init_symbol;
 void update_type_init(symbol_c *symbol /* a spec_init_c, subrange_spec_init_c, etc... */ ) {
 this->current_var_type_symbol = spec_init_sperator_c::get_spec(symbol);
 this->current_var_init_symbol = spec_init_sperator_c::get_init(symbol);
-if (NULL == this->current_var_type_symbol)
+if (NULL == this->current_var_type_symbol) ERROR;
-ERROR;
+if (NULL == this->current_var_type_symbol->datatype) {debug_c::print(this->current_var_type_symbol); ERROR;}
+if (get_datatype_info_c::is_array(this->current_var_type_symbol))
+this->current_var_type_symbol = this->current_var_type_symbol->datatype;
+if (NULL == this->current_var_type_symbol) ERROR;
 if (NULL == this->current_var_init_symbol) {
 /* We try to find the data type's default value... */
 this->current_var_init_symbol = type_initial_value_c::get(this->current_var_type_symbol);
 /* Note that Function Block 'data types' do not have a default value, so we cannot abort if no default value is found! */
 /*
 public:
 generate_c_vardecl_c(stage4out_c *s4o_ptr, varformat_t varformat, unsigned int vartype, symbol_c* res_name = NULL)
-: generate_c_base_c(s4o_ptr) {
+: generate_c_base_and_typeid_c(s4o_ptr) {
 wanted_varformat = varformat;
 wanted_vartype   = vartype;
 current_vartype  = none_vt;
 current_varqualifier = none_vq;
 current_var_type_symbol = NULL;
 */
 /* Start off by setting the current_var_type_symbol and
 * current_var_init_symbol private variables...
 */
-update_type_init(symbol->array_spec_init);
+if (NULL == symbol->array_spec_init->datatype) ERROR;
+update_type_init(symbol->array_spec_init->datatype); // we want to print the name of the base datatype, and nt the derived datatype, so we use '->datatype'!
 /* now to produce the c equivalent... */
 if (wanted_varformat == constructorinit_vf) {
 generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
 array_initialization->set_variable_prefix(get_variable_prefix());
 */
 /* Start off by setting the current_var_type_symbol and
 * current_var_init_symbol private variables...
 */
-update_type_init(symbol->array_specification);
+if (symbol->array_specification->datatype == NULL) {debug_c::print(symbol->array_specification); ERROR;}
+update_type_init(symbol->array_specification->datatype); // we want to print the name of the base datatype, and nt the derived datatype, so we use '->datatype'!
 /* now to produce the c equivalent... */
 if (wanted_varformat == constructorinit_vf) {
 generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
 array_initialization->set_variable_prefix(get_variable_prefix());
 */
 /* Start off by setting the current_var_type_symbol and
 * current_var_init_symbol private variables...
 */
-this->current_var_type_symbol = symbol->specification;
+update_type_init(symbol->specification);
-this->current_var_init_symbol = NULL;
+this->current_var_init_symbol = NULL; // We do NOt want to initialize external variables.
 if(!get_datatype_info_c::is_type_valid(this->current_var_type_symbol)) ERROR;
 bool is_fb = get_datatype_info_c::is_function_block(this->current_var_type_symbol);
 /* now to produce the c equivalent... */
 switch (wanted_varformat) {

changeset 945	477393b00f95
parent 931	c0c245197b5a
child 958	7474d2cd1d6e