matiec: comparison stage4/generate_c/generate_c

equal deleted inserted replaced

-:f2323f79252e
+:31553c22f318
 }
 void *print_getter(symbol_c *symbol) {
 unsigned int vartype = search_var_instance_decl->get_vartype(symbol);
 if (wanted_variablegeneration == fparam_output_vg) {
-	if (vartype == search_var_instance_decl_c::external_vt)
+if (vartype == search_var_instance_decl_c::external_vt) {
-s4o.print(GET_EXTERNAL_BY_REF);
+if (search_var_instance_decl->type_is_fb(symbol))
+s4o.print(GET_EXTERNAL_FB_BY_REF);
+else
+s4o.print(GET_EXTERNAL_BY_REF);
+}
 else if (vartype == search_var_instance_decl_c::located_vt)
 s4o.print(GET_LOCATED_BY_REF);
 else
 s4o.print(GET_VAR_BY_REF);
 }
 else {
-	if (vartype == search_var_instance_decl_c::external_vt)
+if (vartype == search_var_instance_decl_c::external_vt) {
-	  s4o.print(GET_EXTERNAL);
+if (search_var_instance_decl->type_is_fb(symbol))
-	else if (vartype == search_var_instance_decl_c::located_vt)
+s4o.print(GET_EXTERNAL_FB);
-	  s4o.print(GET_LOCATED);
+else
-	else
+s4o.print(GET_EXTERNAL);
-	  s4o.print(GET_VAR);
+}
+else if (vartype == search_var_instance_decl_c::located_vt)
+s4o.print(GET_LOCATED);
+else
+s4o.print(GET_VAR);
 }
 s4o.print("(");
 variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration;
 wanted_variablegeneration = complextype_base_vg;
 wanted_variablegeneration = old_wanted_variablegeneration;
 return NULL;
 }
 void *print_setter(symbol_c* symbol,
-		symbol_c* type,
+symbol_c* type,
-		symbol_c* value,
+symbol_c* value,
-		symbol_c* fb_symbol = NULL,
+symbol_c* fb_symbol = NULL,
-		symbol_c* fb_value = NULL,
+symbol_c* fb_value = NULL,
-		bool negative = false) {
+bool negative = false) {
-bool type_is_complex = false;
+bool type_is_complex = search_var_instance_decl->type_is_complex(symbol);
 if (fb_symbol == NULL) {
 unsigned int vartype = search_var_instance_decl->get_vartype(symbol);
-type_is_complex = search_var_instance_decl->type_is_complex(symbol);
+if (vartype == search_var_instance_decl_c::external_vt) {
-if (vartype == search_var_instance_decl_c::external_vt)
+if (search_var_instance_decl->type_is_fb(symbol))
-s4o.print(SET_EXTERNAL);
+s4o.print(SET_EXTERNAL_FB);
+else
+s4o.print(SET_EXTERNAL);
+}
 else if (vartype == search_var_instance_decl_c::located_vt)
 s4o.print(SET_LOCATED);
 else
 s4o.print(SET_VAR);
 }
-else
+else {
-s4o.print(SET_VAR);
+unsigned int vartype = search_var_instance_decl->get_vartype(fb_symbol);
+if (vartype == search_var_instance_decl_c::external_vt)
+s4o.print(SET_EXTERNAL_FB);
+else
+s4o.print(SET_VAR);
+}
 s4o.print("(");
 if (fb_symbol != NULL) {
 print_variable_prefix();
 fb_symbol->accept(*this);
 wanted_variablegeneration = assignment_vg;
 symbol->accept(*this);
 s4o.print(",");
 if (negative) {
-	    if (search_expression_type->is_bool_type(this->current_operand_type))
+if (search_expression_type->is_bool_type(this->current_operand_type))
-		  s4o.print("!");
+s4o.print("!");
-	    else
+else
-		  s4o.print("~");
+s4o.print("~");
 }
 wanted_variablegeneration = expression_vg;
 print_check_function(type, value, fb_value);
 if (type_is_complex) {
 s4o.print(",");
 break;
 case complextype_base_vg:
 generate_c_base_c::visit(symbol);
 break;
 case complextype_suffix_vg:
-	  break;
+break;
 default:
 if (this->is_variable_prefix_null()) {
-	    vartype = search_var_instance_decl->get_vartype(symbol);
+vartype = search_var_instance_decl->get_vartype(symbol);
 if (wanted_variablegeneration == fparam_output_vg) {
 s4o.print("&(");
 generate_c_base_c::visit(symbol);
 s4o.print(")");
 }
 TRACE("direct_variable_c");
 /* Do not use print_token() as it will change everything into uppercase */
 if (strlen(symbol->value) == 0) ERROR;
 if (this->is_variable_prefix_null()) {
 if (wanted_variablegeneration != fparam_output_vg)
-	  s4o.print("*(");
+s4o.print("*(");
 }
 else {
 switch (wanted_variablegeneration) {
 case expression_vg:
-	    s4o.print(GET_LOCATED);
+s4o.print(GET_LOCATED);
-	    s4o.print("(");
+s4o.print("(");
-	    break;
+break;
 case fparam_output_vg:
 s4o.print(GET_LOCATED_BY_REF);
 s4o.print("(");
 break;
 default:
 }
 }
 this->print_variable_prefix();
 s4o.printlocation(symbol->value + 1);
 if ((this->is_variable_prefix_null() && wanted_variablegeneration != fparam_output_vg) ||
-	  wanted_variablegeneration != assignment_vg)
+wanted_variablegeneration != assignment_vg)
 s4o.print(")");
 return NULL;
 }
 /*************************************/
 s4o.print(".");
 symbol->field_selector->accept(*this);
 }
 break;
 case complextype_suffix_vg:
-	  symbol->record_variable->accept(*this);
+symbol->record_variable->accept(*this);
-	  if (type_is_complex) {
+if (type_is_complex) {
-		s4o.print(".");
+s4o.print(".");
-		symbol->field_selector->accept(*this);
+symbol->field_selector->accept(*this);
-	  }
+}
-	  break;
+break;
-	case assignment_vg:
+case assignment_vg:
-	  symbol->record_variable->accept(*this);
+symbol->record_variable->accept(*this);
-	  s4o.print(".");
+s4o.print(".");
-	  symbol->field_selector->accept(*this);
+symbol->field_selector->accept(*this);
-	  break;
+break;
 default:
 if (this->is_variable_prefix_null()) {
-	symbol->record_variable->accept(*this);
+symbol->record_variable->accept(*this);
-	s4o.print(".");
+s4o.print(".");
-	symbol->field_selector->accept(*this);
+symbol->field_selector->accept(*this);
 }
 else
-	print_getter(symbol);
+print_getter(symbol);
 break;
 }
 return NULL;
 }
 symbol->subscript_list->accept(*this);
 current_array_type = NULL;
 }
 else
-	print_getter(symbol);
+print_getter(symbol);
 break;
 }
 return NULL;
 }
 /* subscript_list ',' subscript */
 void *visit(subscript_list_c *symbol) {
 array_dimension_iterator_c* array_dimension_iterator = new array_dimension_iterator_c(current_array_type);
 for (int i =  0; i < symbol->n; i++) {
 symbol_c* dimension = array_dimension_iterator->next();
-	if (dimension == NULL) ERROR;
+if (dimension == NULL) ERROR;
-	s4o.print("[(");
+s4o.print("[(");
 symbol->elements[i]->accept(*this);
 s4o.print(") - (");
 dimension->accept(*this);
 s4o.print(")]");
 }
 s4o.print("(");
 search_expression_type->default_literal_type(function_type_prefix)->accept(*this);
 s4o.print(")");
 }
 if (function_type_suffix != NULL) {
-	function_type_suffix = search_expression_type->default_literal_type(function_type_suffix);
+function_type_suffix = search_expression_type->default_literal_type(function_type_suffix);
 }
 if (has_output_params) {
 fcall_number++;
 s4o.print("__");
 fbname->accept(*this);
 /* function being called is overloaded! */
 s4o.print("__");
 print_function_parameter_data_types_c overloaded_func_suf(&s4o);
 f_decl->accept(overloaded_func_suf);
 }
 }
 if (function_type_suffix != NULL)
 function_type_suffix->accept(*this);
 }
 s4o.print("(");
 s4o.indent_right();
 /* now output the value assignment */
 if (param_value != NULL)
 if ((param_direction == function_param_iterator_c::direction_in) ||
 (param_direction == function_param_iterator_c::direction_inout)) {
-	if (this->is_variable_prefix_null()) {
+if (this->is_variable_prefix_null()) {
-	  symbol->fb_name->accept(*this);
+symbol->fb_name->accept(*this);
 s4o.print(".");
 param_name->accept(*this);
 s4o.print(" = ");
 print_check_function(param_type, param_value);
-	}
+}
 else {
 print_setter(param_name, param_type, param_value, symbol->fb_name);
 }
 s4o.print(";\n" + s4o.indent_spaces);
 }
 } /* for(...) */
 /* now call the function... */
 function_block_type_name->accept(*this);
 s4o.print(FB_FUNCTION_SUFFIX);
-s4o.print("(&");
+s4o.print("(");
+if (search_var_instance_decl->get_vartype(symbol->fb_name) != search_var_instance_decl_c::external_vt)
+s4o.print("&");
 print_variable_prefix();
 symbol->fb_name->accept(*this);
 s4o.print(")");
 /* loop through each function parameter, find the variable to which
 (param_direction == function_param_iterator_c::direction_inout)) {
 symbol_c *param_type = search_varfb_instance_type->get_type_id(param_value);
 s4o.print(";\n" + s4o.indent_spaces);
 if (this->is_variable_prefix_null()) {
 param_value->accept(*this);
-		  s4o.print(" = ");
+s4o.print(" = ");
-		  print_check_function(param_type, param_name, symbol->fb_name);
+print_check_function(param_type, param_name, symbol->fb_name);
-		}
+}
-		else {
+else {
-		  print_setter(param_value, param_type, param_name, NULL, symbol->fb_name);
+print_setter(param_value, param_type, param_name, NULL, symbol->fb_name);
-		}
+}
 }
 } /* for(...) */
 s4o.print(";\n");
 s4o.indent_left();
 s4o.print("(");
 search_expression_type->default_literal_type(function_type_prefix)->accept(*this);
 s4o.print(")");
 }
 if (function_type_suffix != NULL) {
-	function_type_suffix = search_expression_type->default_literal_type(function_type_suffix);
+function_type_suffix = search_expression_type->default_literal_type(function_type_suffix);
 }
 if (has_output_params) {
 fcall_number++;
 s4o.print("__");
 fbname->accept(*this);
 s4o.print(s4o.indent_spaces);
 return NULL;
 }
 // SYM_REF1(il_simple_instruction_c, il_simple_instruction, symbol_c *prev_il_instruction;)
-void *visit(il_simple_instruction_c *symbol)	{
+void *visit(il_simple_instruction_c *symbol) {
 return symbol->il_simple_instruction->accept(*this);
 }
 /* | il_initial_param_list il_param_instruction */
 /*******************/
 /* B 2.2 Operators */
 /*******************/
-void *visit(LD_operator_c *symbol)	{
+void *visit(LD_operator_c *symbol) {
 if (wanted_variablegeneration != expression_vg) {
 s4o.print("LD");
 return NULL;
 }
 this->default_variable_name.current_type = this->current_operand_type;
 XXX_operator(&(this->default_variable_name), " = ", this->current_operand);
 return NULL;
 }
-void *visit(LDN_operator_c *symbol)	{
+void *visit(LDN_operator_c *symbol) {
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 XXX_operator(&(this->default_variable_name),
 search_expression_type->is_bool_type(this->current_operand_type)?" = !":" = ~",
 this->current_operand);
 return NULL;
 }
-void *visit(ST_operator_c *symbol)	{
+void *visit(ST_operator_c *symbol) {
 symbol_c *operand_type = search_varfb_instance_type->get_type_id(this->current_operand);
 if (search_expression_type->is_literal_integer_type(this->default_variable_name.current_type) ||
-	  search_expression_type->is_literal_real_type(this->default_variable_name.current_type))
+search_expression_type->is_literal_real_type(this->default_variable_name.current_type))
 this->default_variable_name.current_type = this->current_operand_type;
 if (this->is_variable_prefix_null()) {
 this->current_operand->accept(*this);
 s4o.print(" = ");
 print_check_function(operand_type, (symbol_c*)&(this->default_variable_name));
 }
 else {
-	print_setter(this->current_operand, operand_type, (symbol_c*)&(this->default_variable_name));
+print_setter(this->current_operand, operand_type, (symbol_c*)&(this->default_variable_name));
 }
 /* the data type resulting from this operation is unchanged. */
 return NULL;
 }
-void *visit(STN_operator_c *symbol)	{
+void *visit(STN_operator_c *symbol) {
 symbol_c *operand_type = search_varfb_instance_type->get_type_id(this->current_operand);
 if (search_expression_type->is_literal_integer_type(this->default_variable_name.current_type))
-	this->default_variable_name.current_type = this->current_operand_type;
+this->default_variable_name.current_type = this->current_operand_type;
 if (this->is_variable_prefix_null()) {
 this->current_operand->accept(*this);
 s4o.print(" = ");
 if (search_expression_type->is_bool_type(this->current_operand_type))
 s4o.print("!");
 else
-	  s4o.print("~");
+s4o.print("~");
 this->default_variable_name.accept(*this);
 }
 else {
-	print_setter(this->current_operand, operand_type, (symbol_c*)&(this->default_variable_name), NULL, NULL, true);
+print_setter(this->current_operand, operand_type, (symbol_c*)&(this->default_variable_name), NULL, NULL, true);
 }
 /* the data type resulting from this operation is unchanged. */
 return NULL;
 }
-void *visit(NOT_operator_c *symbol)	{
+void *visit(NOT_operator_c *symbol) {
 /* NOTE: the standard allows syntax in which the NOT operator is followed by an optional <il_operand>
 *              NOT [<il_operand>]
 *       However, it does not define the semantic of the NOT operation when the <il_operand> is specified.
 *       We therefore consider it an error if an il_operand is specified!
 *       The error is caught in stage 3!
 &(this->default_variable_name));
 /* the data type resulting from this operation is unchanged. */
 return NULL;
 }
-void *visit(S_operator_c *symbol)	{
+void *visit(S_operator_c *symbol) {
 if (wanted_variablegeneration != expression_vg) {
 s4o.print("LD");
 return NULL;
 }
 ERROR;
 /* the data type resulting from this operation is unchanged! */
 return NULL;
 }
-void *visit(R_operator_c *symbol)	{
+void *visit(R_operator_c *symbol) {
 if (wanted_variablegeneration != expression_vg) {
 s4o.print("LD");
 return NULL;
 }
 void *visit(CD_operator_c *symbol)	{return XXX_CAL_operator("CD", this->current_operand);}
 void *visit(PV_operator_c *symbol)	{return XXX_CAL_operator("PV", this->current_operand);}
 void *visit(IN_operator_c *symbol)	{return XXX_CAL_operator("IN", this->current_operand);}
 void *visit(PT_operator_c *symbol)	{return XXX_CAL_operator("PT", this->current_operand);}
-void *visit(AND_operator_c *symbol)	{
+void *visit(AND_operator_c *symbol) {
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	BYTE_operator_result_type();
+BYTE_operator_result_type();
-	XXX_operator(&(this->default_variable_name), " &= ", this->current_operand);
+XXX_operator(&(this->default_variable_name), " &= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(OR_operator_c *symbol)	{
+void *visit(OR_operator_c *symbol) {
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	BYTE_operator_result_type();
+BYTE_operator_result_type();
-	XXX_operator(&(this->default_variable_name), " |= ", this->current_operand);
+XXX_operator(&(this->default_variable_name), " |= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(XOR_operator_c *symbol)	{
+void *visit(XOR_operator_c *symbol) {
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	BYTE_operator_result_type();
+BYTE_operator_result_type();
-	// '^' is a bit by bit exclusive OR !! Also seems to work with boolean types!
+// '^' is a bit by bit exclusive OR !! Also seems to work with boolean types!
 XXX_operator(&(this->default_variable_name), " ^= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(ANDN_operator_c *symbol)	{
+void *visit(ANDN_operator_c *symbol) {
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	BYTE_operator_result_type();
+BYTE_operator_result_type();
-	XXX_operator(&(this->default_variable_name),
+XXX_operator(&(this->default_variable_name),
 search_expression_type->is_bool_type(this->current_operand_type)?" &= !":" &= ~",
 this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(ORN_operator_c *symbol)	{
+void *visit(ORN_operator_c *symbol) {
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	BYTE_operator_result_type();
+BYTE_operator_result_type();
-	XXX_operator(&(this->default_variable_name),
+XXX_operator(&(this->default_variable_name),
 search_expression_type->is_bool_type(this->current_operand_type)?" |= !":" |= ~",
 this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(XORN_operator_c *symbol)	{
+void *visit(XORN_operator_c *symbol) {
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	BYTE_operator_result_type();
+BYTE_operator_result_type();
-	XXX_operator(&(this->default_variable_name),
+XXX_operator(&(this->default_variable_name),
 // bit by bit exclusive OR !! Also seems to work with boolean types!
 search_expression_type->is_bool_type(this->current_operand_type)?" ^= !":" ^= ~",
 this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(ADD_operator_c *symbol)	{
+void *visit(ADD_operator_c *symbol) {
 if (search_expression_type->is_time_type(this->default_variable_name.current_type) &&
 search_expression_type->is_time_type(this->current_operand_type)) {
 XXX_function("__time_add", &(this->default_variable_name), this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	NUM_operator_result_type();
+NUM_operator_result_type();
-	XXX_operator(&(this->default_variable_name), " += ", this->current_operand);
+XXX_operator(&(this->default_variable_name), " += ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(SUB_operator_c *symbol)	{
+void *visit(SUB_operator_c *symbol) {
 if (search_expression_type->is_time_type(this->default_variable_name.current_type) &&
 search_expression_type->is_time_type(this->current_operand_type)) {
 XXX_function("__time_sub", &(this->default_variable_name), this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	NUM_operator_result_type();
+NUM_operator_result_type();
-	XXX_operator(&(this->default_variable_name), " -= ", this->current_operand);
+XXX_operator(&(this->default_variable_name), " -= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(MUL_operator_c *symbol)	{
+void *visit(MUL_operator_c *symbol) {
 if (search_expression_type->is_time_type(this->default_variable_name.current_type) &&
 search_expression_type->is_integer_type(this->current_operand_type)) {
 XXX_function("__time_mul", &(this->default_variable_name), this->current_operand);
 /* the data type resulting from this operation is unchanged! */
 }
 else if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	NUM_operator_result_type();
+NUM_operator_result_type();
 XXX_operator(&(this->default_variable_name), " *= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(DIV_operator_c *symbol)	{
+void *visit(DIV_operator_c *symbol) {
 if (search_expression_type->is_time_type(this->default_variable_name.current_type) &&
 search_expression_type->is_integer_type(this->current_operand_type)) {
 XXX_function("__time_div", &(this->default_variable_name), this->current_operand);
 /* the data type resulting from this operation is unchanged! */
 }
 else if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	NUM_operator_result_type();
+NUM_operator_result_type();
-	XXX_operator(&(this->default_variable_name), " /= ", this->current_operand);
+XXX_operator(&(this->default_variable_name), " /= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 return NULL;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(MOD_operator_c *symbol)	{
+void *visit(MOD_operator_c *symbol) {
 if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-	NUM_operator_result_type();
+NUM_operator_result_type();
-	XXX_operator(&(this->default_variable_name), " %= ", this->current_operand);
+XXX_operator(&(this->default_variable_name), " %= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
-void *visit(GT_operator_c *symbol)	{
+void *visit(GT_operator_c *symbol) {
 if (!search_base_type.type_is_enumerated(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
 CMP_operator(this->current_operand, "GT_");
 } else {
 ERROR;
 }
 return NULL;
 }
-void *visit(GE_operator_c *symbol)	{
+void *visit(GE_operator_c *symbol) {
 if (!search_base_type.type_is_enumerated(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
 CMP_operator(this->current_operand, "GE_");
 } else {
 ERROR;
 }
 return NULL;
 }
-void *visit(EQ_operator_c *symbol)	{
+void *visit(EQ_operator_c *symbol) {
 if (search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
 CMP_operator(this->current_operand, "EQ_");
 } else {
 ERROR;
 }
 return NULL;
 }
-void *visit(LT_operator_c *symbol)	{
+void *visit(LT_operator_c *symbol) {
 if (!search_base_type.type_is_enumerated(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
 CMP_operator(this->current_operand, "LT_");
 } else {
 ERROR;
 }
 return NULL;
 }
-void *visit(LE_operator_c *symbol)	{
+void *visit(LE_operator_c *symbol) {
 if (!search_base_type.type_is_enumerated(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
 CMP_operator(this->current_operand, "LE_");
 } else {
 ERROR;
 }
 return NULL;
 }
-void *visit(NE_operator_c *symbol)	{
+void *visit(NE_operator_c *symbol) {
 if (search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
 CMP_operator(this->current_operand, "NE_");
 } else {
 ERROR;
 }
 s4o.print("goto ");s4o.print(END_LABEL);
 return NULL;
 }
 //SYM_REF0(JMP_operator_c)
-void *visit(JMP_operator_c *symbol)	{
+void *visit(JMP_operator_c *symbol) {
 if (NULL == this->jump_label) ERROR;
 s4o.print("goto ");
 this->jump_label->accept(*this);
 /* the data type resulting from this operation is unchanged! */
 return NULL;
 }
 // SYM_REF0(JMPC_operator_c)
-void *visit(JMPC_operator_c *symbol)	{
+void *visit(JMPC_operator_c *symbol) {
 if (NULL == this->jump_label) ERROR;
 C_modifier();
 s4o.print("goto ");
 this->jump_label->accept(*this);
 /* the data type resulting from this operation is unchanged! */
 return NULL;
 }
 // SYM_REF0(JMPCN_operator_c)
-void *visit(JMPCN_operator_c *symbol)	{
+void *visit(JMPCN_operator_c *symbol) {
 if (NULL == this->jump_label) ERROR;
 CN_modifier();
 s4o.print("goto ");
 this->jump_label->accept(*this);

changeset 706	31553c22f318
parent 625	c0bda77b37a0
child 793	268bf4ca5fa1