matiec: comparison stage4/generate_c/generate_c

equal deleted inserted replaced

-:f332b62cd2c1
+:c6aed7e5f070
 //#include <string>
 //#include <iostream>
 //#include "../../util/symtable.hh"
+class initialization_analyzer_c: public null_visitor_c {
+public:
+	typedef enum {
+	  simple_it,
+	  array_it,
+	  struct_it
+	} initialization_type_t;
+private:
+	initialization_type_t current_type;
+public:
+	initialization_analyzer_c(symbol_c* symbol) {
+	  current_type = simple_it;
+symbol->accept(*this);
+	}
+	~initialization_analyzer_c(void) {}
+	initialization_type_t get_initialization_type(void) {
+	  return current_type;
+	}
+	void *visit(array_initial_elements_list_c *symbol) {
+current_type = array_it;
+return NULL;
+	}
+void *visit(structure_element_initialization_list_c *symbol) {
+current_type = struct_it;
+return NULL;
+}
+};
 class generate_c_array_initialization_c: public generate_c_typedecl_c {
 public:
 typedef enum {
 s4o.indent_right();
 s4o.print(s4o.indent_spaces + "int index[");
 print_integer(dimension_number);
 s4o.print("];\n");
 s4o.print(s4o.indent_spaces);
+s4o.print("static const ");
 array_specification->accept(*this);
 s4o.print(" temp = ");
 init_array_values(array_initialization);
 s4o.print(";\n");
 if (array_default_initialization != NULL && defined_values_count < array_size)
 array_default_initialization->accept(*this);
 if (defined_values_count < array_size) {
 for (int i = defined_values_count; i < array_size; i++) {
 if (defined_values_count > 0)
-s4o.print(", ");
+s4o.print(",");
 array_default_value->accept(*this);
 defined_values_count++;
 }
 }
 s4o.print("}");
 void *visit(var1_list_c *symbol) {
 int i, j;
 for (i = 0; i < symbol->n; i++) {
 s4o.print(s4o.indent_spaces);
+s4o.print(SET_VAR);
+s4o.print("(");
 print_variable_prefix();
 symbol->elements[i]->accept(*this);
+s4o.print(",temp");
 for (j = 0; j < dimension_number; j++) {
 s4o.print("[index[");
 print_integer(j);
 s4o.print("]]");
 }
-s4o.print(" = temp");
+s4o.print(",");
 for (j = 0; j < dimension_number; j++) {
 s4o.print("[index[");
 print_integer(j);
 s4o.print("]]");
 }
-s4o.print(";\n");
+s4o.print(");\n");
 }
 return NULL;
 }
 /********************************/
 for (int i = 0; i < symbol->n; i++) {
 if (current_initialization_count >= defined_values_count) {
 if (defined_values_count >= array_size)
 ERROR;
 if (defined_values_count > 0)
-s4o.print(", ");
+s4o.print(",");
 symbol->elements[i]->accept(*this);
 defined_values_count++;
 }
 else {
 array_initial_elements_c *array_initial_element = dynamic_cast<array_initial_elements_c *>(symbol->elements[i]);
-if (array_initial_element != NULL)
+if (array_initial_element != NULL) {
-symbol->elements[i]->accept(*this);
+	  symbol->elements[i]->accept(*this);
+}
 }
 current_initialization_count++;
 }
 break;
 default:
 temp_element_number = initial_element_number - diff;
 current_initialization_count += initial_element_number - 1;
 initial_element_number = temp_element_number;
 if (initial_element_number > 0) {
 defined_values_count++;
-s4o.print(", ");
+s4o.print(",");
 }
 }
 else
 current_initialization_count += initial_element_number - 1;
 if (defined_values_count + initial_element_number > array_size)
 ERROR;
 for (int i = 0; i < initial_element_number; i++) {
 if (i > 0)
-s4o.print(", ");
+s4o.print(",");
-if (symbol->array_initial_element != NULL)
+if (symbol->array_initial_element != NULL) {
 symbol->array_initial_element->accept(*this);
-else
+}
+else {
 array_default_value->accept(*this);
+}
 }
 if (initial_element_number > 1)
 defined_values_count += initial_element_number - 1;
 break;
 default:
 current_mode = initializationvalue_sm;
 s4o.print("\n");
 s4o.print(s4o.indent_spaces + "{\n");
 s4o.indent_right();
 s4o.print(s4o.indent_spaces);
+s4o.print("static const ");
 structure_type_name->accept(*this);
 s4o.print(" temp = ");
 structure_initialization->accept(*this);
 s4o.print(";\n");
 int i, j;
 for (i = 0; i < symbol->n; i++) {
 s4o.print(s4o.indent_spaces);
 print_variable_prefix();
+s4o.print(SET_VAR);
+s4o.print("(");
 symbol->elements[i]->accept(*this);
-s4o.print(" = temp;\n");
+s4o.print(",temp);\n");
 }
 return NULL;
 }
 /********************************/
 identifier_c *element_name;
 structure_init_element_iterator_c structure_init_element_iterator(symbol);
 for(int i = 1; (element_name = structure_iterator.next()) != NULL; i++) {
 if (i > 1)
-s4o.print(", ");
+s4o.print(",");
 /* Get the value from an initialization */
 symbol_c *element_value = structure_init_element_iterator.search(element_name);
 if (element_value == NULL) {
 element_value = (symbol_c *)current_element_type->accept(*type_initial_value_c::instance());
 }
 if (element_value == NULL) ERROR;
-structure_element_initialization_list_c *structure_element_initialization_list = dynamic_cast<structure_element_initialization_list_c *>(element_value);
+initialization_analyzer_c initialization_analyzer(element_value);
-if (structure_element_initialization_list != NULL) {
+if (initialization_analyzer.get_initialization_type() == initialization_analyzer_c::struct_it) {
 generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
 structure_initialization->set_variable_prefix(get_variable_prefix());
 structure_initialization->init_structure_default(current_element_type);
 structure_initialization->current_mode = generate_c_structure_initialization_c::initializationvalue_sm;
 element_value->accept(*structure_initialization);
 delete structure_initialization;
 }
-else
+else {
 element_value->accept(*this);
+}
 }
 s4o.print("}");
 return NULL;
 }
 static const unsigned int en_vt       = 0x0200;  // EN  declaration
 static const unsigned int eno_vt      = 0x0400;  // ENO declaration
 static const unsigned int resource_vt = 0x8000;  // RESOURCE (inside a configuration!)
 //    This, just of itself, will not print out any declarations!!
 						     //    It must be acompanied by either program_vt and/or global_vt
+/* the qualifier of variables that need to be processed... */
+static const unsigned int none_vq        = 0x0000;
+static const unsigned int constant_vq    = 0x0001;  // CONSTANT
+static const unsigned int retain_vq      = 0x0002;  // RETAIN
+static const unsigned int non_retain_vq  = 0x0004;  // NON_RETAIN
 /* How variables should be declared: as local variables or
 * variables within a function call interface.
 *
 * This will define the format of the output generated
 private:
 /* variable used to store the types of variables that need to be processed... */
 /* Only set in the constructor...! */
 /* Will contain a set of values of generate_c_vardecl_c::XXXX_vt */
 unsigned int wanted_vartype;
 /* variable used to store the type of variable currently being processed... */
 /* Will contain a single value of generate_c_vardecl_c::XXXX_vt */
 unsigned int current_vartype;
+/* variable used to store the qualifier of variable currently being processed... */
+/* Will contain a single value of generate_c_vardecl_c::XXXX_vq */
+unsigned int current_varqualifier;
 /* How variables should be declared: as local variables or
 * variables within a function interface...
 */
 /* Only set in the constructor...! */
 * the identifier of the scope within which the static member was
 * declared.
 */
 symbol_c *globalnamespace;
+void *print_retain(void) {
+	  s4o.print(",");
+switch (current_varqualifier) {
+		case retain_vq:
+s4o.print("1");
+break;
+case non_retain_vq:
+s4o.print("0");
+break;
+		default:
+		  s4o.print("retain");
+		  break;
+}
+return NULL;
+}
 /* Actually produce the output where variables are declared... */
 /* Note that located variables and EN/ENO are the exception, they
 * being declared in the located_var_decl_c,
 * en_param_declaration_c and eno_param_declaration_c visitors...
 */
 (wanted_varformat == init_vf) ||
 (wanted_varformat == localinit_vf)) {
 for(int i = 0; i < list->n; i++) {
 s4o.print(s4o.indent_spaces);
 if (wanted_varformat == local_vf) {
-	s4o.print(DECLARE_VAR);
+	if (!is_fb) {
-	s4o.print("(");
+	  s4o.print(DECLARE_VAR);
+	  s4o.print("(");
+	}
 	this->current_var_type_symbol->accept(*this);
-s4o.print(",");
+	if (is_fb)
+	  s4o.print(" ");
+	else
+	  s4o.print(",");
 }
 else if (wanted_varformat == localinit_vf) {
 	this->current_var_type_symbol->accept(*this);
 s4o.print(" ");
 }
 s4o.print(" = ");
 this->current_var_init_symbol->accept(*this);
 }
 s4o.print(";\n");
 }
+else if (is_fb)
+	s4o.print(";\n");
 else
-	s4o.print(")\n");
+s4o.print(")\n");
 }
 }
 if (wanted_varformat == finterface_vf) {
 for(int i = 0; i < list->n; i++) {
 this->current_var_type_symbol->accept(*this);
 s4o.print(FB_INIT_SUFFIX);
 s4o.print("(&");
 this->print_variable_prefix();
 list->elements[i]->accept(*this);
+print_retain();
 s4o.print(");");
 }
 else if (this->current_var_init_symbol != NULL) {
 s4o.print(nv->get());
 s4o.print(INIT_VAR);
 s4o.print("(");
 this->print_variable_prefix();
 list->elements[i]->accept(*this);
 s4o.print(",");
 this->current_var_init_symbol->accept(*this);
+print_retain();
 s4o.print(")");
 }
 }
 }
 generate_c_vardecl_c(stage4out_c *s4o_ptr, varformat_t varformat, unsigned int vartype, symbol_c* res_name = NULL)
 : generate_c_typedecl_c(s4o_ptr) {
 wanted_varformat = varformat;
 wanted_vartype   = vartype;
 current_vartype  = none_vt;
+current_varqualifier = none_vq;
 current_var_type_symbol = NULL;
 current_var_init_symbol = NULL;
 globalnamespace         = NULL;
 nv = NULL;
 resource_name = res_name;
 /* done in base class(es) */
 /******************************************/
 /* B 1.4.3 - Declaration & Initialisation */
 /******************************************/
-void *visit(constant_option_c *symbol) {s4o.print("CONSTANT"); return NULL;}
-void *visit(retain_option_c *symbol) {s4o.print("RETAIN"); return NULL;}
+void *visit(constant_option_c *symbol) {
-void *visit(non_retain_option_c *symbol) {s4o.print("NON_RETAIN"); return NULL;}
+current_varqualifier = constant_vq;
+return NULL;
+}
+void *visit(retain_option_c *symbol) {
+current_varqualifier = retain_vq;
+return NULL;
+}
+void *visit(non_retain_option_c *symbol) {
+current_varqualifier = non_retain_vq;
+return NULL;
+}
 void *visit(input_declarations_c *symbol) {
 TRACE("input_declarations_c");
 if ((wanted_vartype & input_vt) != 0) {
 /*
 if (symbol->option != NULL)
 symbol->option->accept(*this);
 */
 //s4o.indent_right();
 current_vartype = input_vt;
+if (symbol->option != NULL)
+symbol->option->accept(*this);
 symbol->input_declaration_list->accept(*this);
 current_vartype = none_vt;
+current_varqualifier = none_vt;
 //s4o.indent_left();
 }
 return NULL;
 }
 this->print_variable_prefix();
 // s4o.print("EN = __BOOL_LITERAL(TRUE);");
 symbol->name->accept(*this);
 s4o.print(",");
 symbol->value->accept(*this);
+print_retain();
 s4o.print(")");
 }
 }
 return NULL;
 }
 s4o.print(INIT_VAR);
 s4o.print("(");
 this->print_variable_prefix();
 // s4o.print("ENO = __BOOL_LITERAL(TRUE);");
 symbol->name->accept(*this);
-s4o.print(",__BOOL_LITERAL(TRUE))");
+s4o.print(",__BOOL_LITERAL(TRUE)");
+print_retain();
+s4o.print(")");
 }
 }
 return NULL;
 }
 if (symbol->option != NULL)
 symbol->option->accept(*this);
 */
 //s4o.indent_right();
 current_vartype = output_vt;
+if (symbol->option != NULL)
+symbol->option->accept(*this);
 symbol->var_init_decl_list->accept(*this);
 current_vartype = none_vt;
+current_varqualifier = none_vq;
 //s4o.indent_left();
 }
 return NULL;
 }
 // TO DO ...
 if (symbol->option != NULL)
 symbol->option->accept(*this);
 */
 current_vartype = private_vt;
+if (symbol->option != NULL)
+symbol->option->accept(*this);
 symbol->var_init_decl_list->accept(*this);
 current_vartype = none_vt;
+current_varqualifier = none_vq;
 }
 return NULL;
 }
 /*  VAR RETAIN var_init_decl_list END_VAR */
 void *visit(retentive_var_declarations_c *symbol) {
 TRACE("retentive_var_declarations_c");
 if ((wanted_vartype & private_vt) != 0) {
 current_vartype = private_vt;
+current_varqualifier = retain_vq;
 symbol->var_init_decl_list->accept(*this);
 current_vartype = none_vt;
+current_varqualifier = none_vq;
 }
 return NULL;
 }
 /*  VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */
 // TO DO ...
 if (symbol->option != NULL)
 symbol->option->accept(*this);
 */
 current_vartype = located_vt;
+if (symbol->option != NULL)
+symbol->option->accept(*this);
 symbol->located_var_decl_list->accept(*this);
 current_vartype = none_vt;
+current_varqualifier = none_vq;
 }
 return NULL;
 }
 /* helper symbol for located_var_declarations */
 symbol->variable_name->accept(*this);
 else
 symbol->location->accept(*this);
 s4o.print(",");
 print_variable_prefix();
+print_retain();
 s4o.print(")\n");
 if (this->current_var_init_symbol != NULL) {
 	s4o.print(INIT_LOCATED_VALUE);
 	s4o.print("(");
 	if (symbol->variable_name != NULL)
 if (symbol->option != NULL)
 symbol->option->accept(*this);
 */
 //s4o.indent_right();
 current_vartype = external_vt;
+if (symbol->option != NULL)
+symbol->option->accept(*this);
 symbol->external_declaration_list->accept(*this);
 current_vartype = none_vt;
+current_varqualifier = none_vq;
 //s4o.indent_left();
 }
 return NULL;
 }
 s4o.print(",");
 symbol->global_var_name->accept(*this);
 s4o.print(",");
 print_variable_prefix();
 symbol->global_var_name->accept(*this);
+print_retain();
 s4o.print(")");
 break;
 case finterface_vf:
 finterface_var_count++;
 */
 //s4o.indent_right();
 unsigned int previous_vartype = current_vartype;
 // previous_vartype will be either none_vt, or resource_vt
 current_vartype = global_vt;
+if (symbol->option != NULL)
+symbol->option->accept(*this);
 symbol->global_var_decl_list->accept(*this);
 current_vartype = previous_vartype;
+current_varqualifier = none_vq;
 //s4o.indent_left();
 }
 return NULL;
 }
 	}
 s4o.print(",");
 symbol->global_var_name->accept(*this);
 	s4o.print(",");
 	symbol->location->accept(*this);
+print_retain();
 	s4o.print(")");
 }
 if (this->current_var_init_symbol != NULL) {
 	    s4o.print(nv->get());
 	    s4o.print(s4o.indent_spaces);
 		  symbol->global_var_name->accept(*this);
 	    else
 		  symbol->location->accept(*this);
 	    s4o.print(",");
 	    this->current_var_init_symbol->accept(*this);
+	    print_retain();
 	    s4o.print(")");
 }
 break;
 default:
 s4o.print(INIT_GLOBAL);
 s4o.print("(");
 list->elements[i]->accept(*this);
 s4o.print(",");
 this->current_var_init_symbol->accept(*this);
+print_retain();
 s4o.print(")");
 #if 0
 	  /* The following code would be for globalinit_vf !!
 	   * But it is not currently required...
 	   */

changeset 221	c6aed7e5f070
parent 217	f5dfadf5de54
child 226	29f8ffc203c1