757 class generate_c_datatypes_c: public generate_c_typedecl_c {

   757 identifier_c *generate_unique_id(symbol_c *clone = NULL) {

   758   public:

   758   static int counter = 0;

   759     typedef enum {

   759   

   760       none_im,

   760   counter++;

   761       arrayname_im,

   761   int   len = snprintf(NULL, 0, "__UNIQUE_ID_%d", counter);

   762       arraydeclaration_im

   762   char *str = (char *)malloc(len+1);

   763     } inlinearray_mode_t;

   763   if (snprintf(str, len+1, "__UNIQUE_ID_%d", counter) < 0) ERROR;

   764 

   764   

   765   identifier_c *id = new identifier_c(str);

   766   if (NULL == id) ERROR;

   767   if (NULL != clone)

   768     *(dynamic_cast<symbol_c *>(id)) = *(dynamic_cast<symbol_c *>(clone));

   769   return id;

   770 }

   771 

   772 

   773 

   774 class generate_c_datatypes_c: public iterator_visitor_c {

   766     std::map<std::string, int> inline_array_defined;

   776     generate_c_typedecl_c generate_c_typedecl;

   767     std::string current_array_name;

   768     inlinearray_mode_t current_mode;

   769 

   772       : generate_c_typedecl_c(s4o_incl_ptr) {

   779       : generate_c_typedecl(s4o_incl_ptr) {

   773       current_mode = none_im;

   921     void *visit(input_declarations_c *symbol) {

   805     void *visit(edge_declaration_c           *symbol) {return NULL;}

   922       symbol->input_declaration_list->accept(*this);

   806     void *visit(en_param_declaration_c       *symbol) {return NULL;}

   923       return NULL;

   807     void *visit(eno_param_declaration_c      *symbol) {return NULL;}

   924     }

   808 

   925 

   809     void *visit(var1_init_decl_c             *symbol) {return NULL;}

   926     void *visit(edge_declaration_c *symbol) {

   927       return NULL;

   928     }

   929 

   930     void *visit(en_param_declaration_c *symbol) {

   931       return NULL;

   932     }

   933 

   934     void *visit(eno_param_declaration_c *symbol) {

   935       return NULL;

   936     }

   937 

   938     void *visit(var1_init_decl_c *symbol) {

   939       return NULL;

   940     }

   941 

   942     /*  var1_list ':' array_spec_init */

   943     // SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   944     void *visit(array_var_init_decl_c *symbol) {

   945       current_mode = arraydeclaration_im;

   946       symbol->array_spec_init->accept(*this);

   947       current_mode = none_im;

   948       return NULL;

   949     }

   954       switch (current_mode) {

   814       symbol->array_specification->accept(*this);

   955         case arraydeclaration_im:

   815       int implicit_id_count = symbol->array_specification->anotations_map.count("generate_c_annotaton__implicit_type_id");

   956           {

   816       if (implicit_id_count  > 1) ERROR;

   957             array_specification_c *specification = dynamic_cast<array_specification_c*>(symbol->array_specification);

   817       if (implicit_id_count == 1)

   958             if (specification != NULL)

   818         symbol->anotations_map["generate_c_annotaton__implicit_type_id"] = symbol->array_specification->anotations_map["generate_c_annotaton__implicit_type_id"];

   959               symbol->array_specification->accept(*this);

   960           }

   961           break;

   962         case arrayname_im:

   963           {

   964             array_specification_c *specification = dynamic_cast<array_specification_c*>(symbol->array_specification);

   965             if (specification != NULL)

   966               symbol->array_specification->accept(*this);

   967             identifier_c *name = dynamic_cast<identifier_c*>(symbol->array_specification);

   968             if (name != NULL)

   969               s4o_incl.print(name->value);

   970           }

   971           break;

   972         default:

   973           return generate_c_typedecl_c::visit(symbol);

   974           break;

   975       }

   981       switch (current_mode) {

   824       identifier_c *id = generate_unique_id(symbol);

   982         case arraydeclaration_im:

   825       /* Warning: The following is dangerous... 

   983           {

   826        * We are asking the generate_c_typedecl_c visitor to visit a newly created array_type_declaration_c object

   984             current_mode = arrayname_im;

   827        * that has not been through stage 3, and therefore does not have stage 3 annotations filled in.

   985             std::map<std::string,int>::iterator definition;

   828        * This will only work if generate_c_typedecl_c does ot depend on the stage 3 annotations!

   986             current_array_name = "__";

   829        */

   987             symbol->non_generic_type_name->accept(*this);

   830       array_spec_init_c        array_spec(symbol, NULL);

   988             symbol->array_subrange_list->accept(*this);

   831       array_type_declaration_c array_decl(id, &array_spec);

   989             current_mode = arraydeclaration_im;

   832       array_decl.accept(generate_c_typedecl); // Must be done _before_ adding the annotation, due to the way generate_c_typedecl_c works

   990 

   833       symbol->anotations_map["generate_c_annotaton__implicit_type_id"] = id;

   991             definition = inline_array_defined.find(current_array_name);

   834       return NULL;

   992             if (definition == inline_array_defined.end()) {

   835     }

   993               s4o_incl.print("__DECLARE_ARRAY_TYPE(");

   836     

   994               s4o_incl.print(current_array_name);

   995               s4o_incl.print(",");

   996               symbol->non_generic_type_name->accept(*this);

   997               s4o_incl.print(",");

   998               symbol->array_subrange_list->accept(*this);

   999               s4o_incl.print(")\n\n");

  1000 

  1001               inline_array_defined[current_array_name] = 0; // insert an element, indicating this array type has been defined!

  1002             }

  1003           }

  1004           break;

  1005         case arrayname_im:

  1006           {

  1007               std::map<std::string,int>::iterator definition;

  1008               current_array_name = "__";

  1009               symbol->non_generic_type_name->accept(*this);

  1010               symbol->array_subrange_list->accept(*this);

  1011               s4o_incl.print(current_array_name);

  1012           }

  1013           break;

  1014         default:

  1015           return generate_c_typedecl_c::visit(symbol);

  1016           break;

  1017       }

  1018       return NULL;

  1019     }

  1020 

  1021     /*  signed_integer DOTDOT signed_integer */

  1022     //SYM_REF2(subrange_c, lower_limit, upper_limit)

  1023     void *visit(subrange_c *symbol) {

  1024       switch (current_mode) {

  1025         case arrayname_im:

  1026           current_array_name += "_";

  1027           {

  1028             std::stringstream ss;

  1029             ss << symbol->dimension;

  1030             current_array_name += ss.str();

  1031           }

  1032           break;

  1033         case arraydeclaration_im:

  1034           s4o_incl.print("[");

  1035           s4o_incl.print(symbol->dimension);

  1036           s4o_incl.print("]");

  1037         default:

  1038           generate_c_typedecl_c::visit(symbol);

  1039           break;

  1040       }

  1041       return NULL;

  1042     }

  1043 

  1046     void *visit(structured_var_init_decl_c *symbol) {

   839     void *visit(structured_var_init_decl_c   *symbol) {return NULL;}

  1047       return NULL;

  1048     }

  1052     void *visit(fb_name_decl_c *symbol) {

   843     void *visit(fb_name_decl_c               *symbol) {return NULL;}

  1053       return NULL;

  1054     }

  1055 

  1056     /* VAR_OUTPUT [RETAIN | NON_RETAIN] var_init_decl_list END_VAR */

  1057     /* option -> may be NULL ! */

  1058     void *visit(output_declarations_c *symbol) {

  1059       symbol->var_init_decl_list->accept(*this);

  1060       return NULL;

  1061     }

  1062 

  1063     /*  VAR_IN_OUT var_declaration_list END_VAR */

  1064     void *visit(input_output_declarations_c *symbol) {

  1065       symbol->var_declaration_list->accept(*this);

  1066       return NULL;

  1067     }

  1068 

  1069     /*  var1_list ':' array_specification */

  1070     //SYM_REF2(array_var_declaration_c, var1_list, array_specification)

  1071     void *visit(array_var_declaration_c *symbol) {

  1072       array_specification_c *specification = dynamic_cast<array_specification_c*>(symbol->array_specification);

  1073       if (specification != NULL) {

  1074         current_mode = arraydeclaration_im;

  1075         symbol->array_specification->accept(*this);

  1076         current_mode = none_im;

  1077       }

  1078       return NULL;

  1079     }

  1083     void *visit(structured_var_declaration_c *symbol) {

   847     void *visit(structured_var_declaration_c *symbol) {return NULL;}

  1084       return NULL;

  1085     }

  1086 

  1087     /* VAR [CONSTANT] var_init_decl_list END_VAR */

  1088     /* option -> may be NULL ! */

  1089     /* helper symbol for input_declarations */

  1090     void *visit(var_declarations_c *symbol) {

  1091       symbol->var_init_decl_list->accept(*this);

  1092       return NULL;

  1093     }

  1094 

  1095     /*  VAR RETAIN var_init_decl_list END_VAR */

  1096     void *visit(retentive_var_declarations_c *symbol) {

  1097       symbol->var_init_decl_list->accept(*this);

  1098       return NULL;

  1099     }

  1100 

  1101     /*  VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */

  1102     /* option -> may be NULL ! */

  1103     //SYM_REF2(located_var_declarations_c, option, located_var_decl_list)

  1104     void *visit(located_var_declarations_c *symbol) {

  1105       symbol->located_var_decl_list->accept(*this);

  1106       return NULL;

  1107     }

  1108 

  1109     /*  [variable_name] location ':' located_var_spec_init */

  1110     /* variable_name -> may be NULL ! */

  1111     //SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused)

  1112     void *visit(located_var_decl_c *symbol) {

  1113       array_spec_init_c* array_spec_init = dynamic_cast<array_spec_init_c*>(symbol->located_var_spec_init);

  1114       if (array_spec_init != NULL) {

  1115         current_mode = arraydeclaration_im;

  1116         symbol->located_var_spec_init->accept(*this);

  1117         current_mode = none_im;

  1118       }

  1119       return NULL;

  1120     }

  1121 

  1122     /*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */

  1123     /* option -> may be NULL ! */

  1124     //SYM_REF2(external_var_declarations_c, option, external_declaration_list)

  1125     void *visit(external_var_declarations_c *symbol) {

  1126       symbol->external_declaration_list->accept(*this);

  1127       return NULL;

  1128     }

  1129 

  1130     /*  global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */

  1131     //SYM_REF2(external_declaration_c, global_var_name, specification)

  1132     void *visit(external_declaration_c *symbol) {

  1133       array_specification_c* array_specification = dynamic_cast<array_specification_c*>(symbol->specification);

  1134       if (array_specification != NULL) {

  1135         current_mode = arraydeclaration_im;

  1136         symbol->specification->accept(*this);

  1137         current_mode = none_im;

  1138       }

  1139       return NULL;

  1140     }

  1141 

  1142     /*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */

  1143     /* option -> may be NULL ! */

  1144     // SYM_REF2(global_var_declarations_c, option, global_var_decl_list)

  1145     void *visit(global_var_declarations_c *symbol) {

  1146       symbol->global_var_decl_list->accept(*this);

  1147       return NULL;

  1148     }

  1149 

  1150     /*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */

  1151     /* type_specification ->may be NULL ! */

  1152     // SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

  1153     void *visit(global_var_decl_c *symbol) {

  1154       array_spec_init_c* array_spec_init = dynamic_cast<array_spec_init_c*>(symbol->type_specification);

  1155       if (array_spec_init != NULL) {

  1156         current_mode = arraydeclaration_im;

  1157         symbol->type_specification->accept(*this);

  1158         current_mode = none_im;

  1159       }

  1160       return NULL;

  1161     }

  1162 

  1163     void *visit(function_var_decls_c *symbol) {

  1164       symbol->decl_list->accept(*this);

  1165       return NULL;

  1166     }

  1167 

  1168     /*****************************/

  1169     /* B 1.5.2 - Function Blocks */

  1170     /*****************************/

  1171 

  1172     /*  VAR_TEMP temp_var_decl_list END_VAR */

  1173     void *visit(temp_var_decls_c *symbol) {

  1174       symbol->var_decl_list->accept(*this);

  1175       return NULL;

  1176     }

  1177 

  1178     /*  VAR NON_RETAIN var_init_decl_list END_VAR */

  1179     void *visit(non_retentive_var_decls_c *symbol) {

  1180       symbol->var_decl_list->accept(*this);

  1181       return NULL;

  1182     }

  2488     stage4out_c &s4o;

  2158     stage4out_c                      &s4o;

  2489     stage4out_c pous_s4o;

  2159     stage4out_c                  pous_s4o;

  2490     stage4out_c pous_incl_s4o;

  2160     stage4out_c             pous_incl_s4o;

  2491     stage4out_c located_variables_s4o;

  2161     stage4out_c     located_variables_s4o;

  2492     stage4out_c variables_s4o;

  2162     stage4out_c             variables_s4o;

  2163     

  2494     generate_c_pous_c generate_c_pous;

  2165     generate_c_typedecl_c  generate_c_typedecl;

  2495     

  2166     generate_c_pous_c      generate_c_pous;

  2496     symbol_c *current_configuration;

  2167     

  2168     symbol_c   *current_configuration;

  2512             generate_c_datatypes(&pous_incl_s4o)

  2184             generate_c_datatypes(&pous_incl_s4o),

  2185             generate_c_typedecl (&pous_incl_s4o)

  2586     void *visit(data_type_declaration_c *symbol) {

  2259 //   void *visit(data_type_declaration_c *symbol)  // handled by iterator_visitor_c

  2587       symbol->accept(generate_c_datatypes);

  2260 

  2261     /* helper symbol for data_type_declaration */

  2262     void *visit(type_declaration_list_c *symbol) {

  2263       for(int i = 0; i < symbol->n; i++) {

  2264         symbol->elements[i]->accept(generate_c_datatypes);

  2265         symbol->elements[i]->accept(generate_c_typedecl);

  2266       }