862       s4o.print(s4o.indent_spaces);

   862       /* NOTE: matiec supports a non-standard syntax, in which functions do not return a value

   863       symbol->type_name->accept(print_base); /* return type */

   863        *       (declared as returning the special non-standard datatype VOID)

   864       s4o.print(" ");

   864        *       e.g.:   FUNCTION foo: VOID

   865       symbol->derived_function_name->accept(print_base);

   865        *                ...

   866       s4o.print(" = ");

   866        *               END_FUNCTION

   867       {

   867        *       

   868         /* get the default value of this variable's type */

   868        *       These functions cannot return any value, so they do not need a variable to

   869         symbol_c *default_value = type_initial_value_c::get(symbol->type_name);

   869        *       store the return value.

   870         if (default_value == NULL) ERROR;

   870        *       Note that any attemot to sto a value in the implicit variable

   871         initialization_analyzer_c initialization_analyzer(default_value);

   871        *       e.g.:   FUNCTION foo: VOID

   872         switch (initialization_analyzer.get_initialization_type()) {

   872        *                ...

   873           case initialization_analyzer_c::struct_it:

   873        *                 foo := 42;

   874             {

   874        *               END_FUNCTION

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

   875        *       will always return a datatype incompatilibiyt error in stage 3 of matiec, 

   876               structure_initialization->init_structure_default(symbol->type_name);

   876        *       so it is safe for stage 4 to assume that this return variable will never be needed

   877               structure_initialization->init_structure_values(default_value);

   877        *       if the function's return type is VOID.

   878               delete structure_initialization;

   878        */

   879             }

   879       if (!get_datatype_info_c::is_VOID(symbol->type_name->datatype)) { // only print return variable if return datatype is not VOID

   880             break;

   880         s4o.print(s4o.indent_spaces);

   881           case initialization_analyzer_c::array_it:

   881         symbol->type_name->accept(print_base); /* return type */

   882             {

   882         s4o.print(" ");

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

   883         symbol->derived_function_name->accept(print_base);

   884               array_initialization->init_array_size(symbol->type_name);

   884         s4o.print(" = ");

   885               array_initialization->init_array_values(default_value);

   885         {

   886               delete array_initialization;

   886           /* get the default value of this variable's type */

   887             }

   887           symbol_c *default_value = type_initial_value_c::get(symbol->type_name);

   888             break;

   888           if (default_value == NULL) ERROR;

   889           default:

   889           initialization_analyzer_c initialization_analyzer(default_value);

   890             default_value->accept(print_base);

   890           switch (initialization_analyzer.get_initialization_type()) {

   891             break;

   891             case initialization_analyzer_c::struct_it:

   892               {

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

   894                 structure_initialization->init_structure_default(symbol->type_name);

   895                 structure_initialization->init_structure_values(default_value);

   896                 delete structure_initialization;

   897               }

   898               break;

   899             case initialization_analyzer_c::array_it:

   900               {

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

   902                 array_initialization->init_array_size(symbol->type_name);

   903                 array_initialization->init_array_values(default_value);

   904                 delete array_initialization;

   905               }

   906               break;

   907             default:

   908               default_value->accept(print_base);

   909               break;

   910           }

   912         s4o.print(s4o.indent_spaces + "return ");

   931         if (!get_datatype_info_c::is_VOID(symbol->type_name->datatype)) { // only print return variable if return datatype is not VOID

   913         symbol->derived_function_name->accept(print_base);

   932           s4o.print(s4o.indent_spaces + "return ");

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

   933           symbol->derived_function_name->accept(print_base);

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

   935         }

   933       s4o.print(s4o.indent_spaces + "return ");

   954       if (!get_datatype_info_c::is_VOID(symbol->type_name->datatype)) { // only print 'return <fname>' if return datatype is not VOID

   934       symbol->derived_function_name->accept(print_base);

   955         s4o.print(s4o.indent_spaces + "return ");

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

   956         symbol->derived_function_name->accept(print_base);

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

   958       }

   959