107   identifier_c *name1 = dynamic_cast<identifier_c *>(ident1);

   107   token_c *name1 = dynamic_cast<token_c *>(ident1);

   108   identifier_c *name2 = dynamic_cast<identifier_c *>(ident2);

   108   token_c *name2 = dynamic_cast<token_c *>(ident2);

   109 

   109   

   216 

   218 /***********************************************************************/

   219 /***********************************************************************/

   220 /***********************************************************************/

   221 /***********************************************************************/

   222 

   223 #define MILLISECOND 1000000

   224 #define SECOND 1000 * MILLISECOND

   225 

   226 /* A helper class that knows how to generate code for both the IL and ST languages... */

   227 class calculate_time_c: public iterator_visitor_c {

   228   private:

   229     unsigned long time;

   230     float current_value;

   231   

   232   public:

   233     calculate_time_c(void){time = 0;};

   234     

   235     unsigned long get_time(void) {return time;};

   236 

   237     void *get_integer_value(token_c *token) {

   238       std::string str = "";

   239       for (unsigned int i = 0; i < strlen(token->value); i++)

   240         if (token->value[i] != '_')

   241           str += token->value[i];

   242       current_value = atof(str.c_str());

   243       return NULL;

   244     }

   245 

   246     void *get_float_value(token_c *token) {

   247       current_value = atof(token->value);

   248       return NULL;

   249     }

   250 

   251 /******************************/

   252 /* B 1.2.1 - Numeric Literals */

   253 /******************************/

   254 

   255     void *visit(integer_c *symbol) {return get_integer_value(symbol);}

   256     

   257 /************************/

   258 /* B 1.2.3.1 - Duration */

   259 /************************/

   260   

   261     /* SYM_REF2(duration_c, neg, interval) */

   262     void *visit(duration_c *symbol) {

   263       if (symbol->neg != NULL)

   264         ERROR;

   265       symbol->interval->accept(*this);

   266       return NULL;

   267     }

   268     

   269     /* SYM_TOKEN(fixed_point_c) */

   270     void *visit(fixed_point_c *symbol) {return get_float_value(symbol);}

   271     

   272     /* SYM_REF2(days_c, days, hours) */

   273     void *visit(days_c *symbol) {

   274       if (symbol->hours)

   275         symbol->hours->accept(*this);

   276       symbol->days->accept(*this);

   277       time += (unsigned long)(current_value * 24 * 3600 * SECOND);

   278       return NULL;

   279     }

   280     

   281     /* SYM_REF2(hours_c, hours, minutes) */

   282     void *visit(hours_c *symbol) {

   283       if (symbol->minutes)

   284         symbol->minutes->accept(*this);

   285       symbol->hours->accept(*this);

   286       time += (unsigned long)(current_value * 3600 * SECOND);

   287       return NULL;

   288     }

   289     

   290     /* SYM_REF2(minutes_c, minutes, seconds) */

   291     void *visit(minutes_c *symbol) {

   292       if (symbol->seconds)

   293         symbol->seconds->accept(*this);

   294       symbol->minutes->accept(*this);

   295       time += (unsigned long)(current_value * 60 * SECOND);

   296       return NULL;

   297     }

   298     

   299     /* SYM_REF2(seconds_c, seconds, milliseconds) */

   300     void *visit(seconds_c *symbol) {

   301       if (symbol->milliseconds)

   302         symbol->milliseconds->accept(*this);

   303       symbol->seconds->accept(*this);

   304       time += (unsigned long)(current_value * SECOND);

   305       return NULL;

   306     }

   307     

   308     /* SYM_REF2(milliseconds_c, milliseconds, unused) */

   309     void *visit(milliseconds_c *symbol) {

   310       symbol->milliseconds->accept(*this);

   311       time += (unsigned long)(current_value * MILLISECOND);

   312       return NULL;

   313     }

   314 };

   315 

   316 /***********************************************************************/

   317 /***********************************************************************/

   318 /***********************************************************************/

   319 /***********************************************************************/

   320 

   321 class calculate_common_ticktime_c: public iterator_visitor_c {

   322   private:

   323     unsigned long common_ticktime;

   324     

   325   public:

   326     calculate_common_ticktime_c(void){common_ticktime = 0;}

   327     

   328     unsigned long euclide(unsigned long a, unsigned long b) {

   329       unsigned long c = a % b;

   330       if (c == 0)

   331         return b;

   332       else

   333         return euclide(b, c);

   334     }

   335     

   336     void update_ticktime(unsigned long time) {

   337       if (common_ticktime == 0)

   338         common_ticktime = time;

   339       else if (time > common_ticktime)

   340         common_ticktime = euclide(time, common_ticktime);

   341       else

   342         common_ticktime = euclide(common_ticktime, time);

   343     }

   344 

   345     unsigned long get_ticktime(void) {

   346       return common_ticktime;

   347     }

   348 

   349 /*  TASK task_name task_initialization */

   350 //SYM_REF2(task_configuration_c, task_name, task_initialization)  

   351     void *visit(task_initialization_c *symbol) {

   352       calculate_time_c calculate_time;

   353       unsigned long time = 0;

   354       if (symbol->interval_data_source != NULL) {

   355         symbol->interval_data_source->accept(calculate_time);

   356         time = calculate_time.get_time();

   357       }

   358       if (time > 0)

   359         update_ticktime(time);

   360       return NULL;

   361     }

   362 };    

   531 				      generate_cc_vardecl_c::temp_vt |

   677 				        generate_cc_vardecl_c::temp_vt |

   568 				      generate_cc_vardecl_c::located_vt |

   714 				        generate_cc_vardecl_c::located_vt |

   569 				      generate_cc_vardecl_c::external_vt);

   715 				        generate_cc_vardecl_c::external_vt);

   784   public:

   915     public:

   810   TRACE("configuration_declaration_c");

   948   

   811 

   949   /* (A) configuration declaration... */

   812   configuration_count++;

   813   if (configuration_count == 1) {

   814     /* the first configuration is the one we will use!! */

   815     s4o.print("#define __configuration_c ");

   816     symbol->configuration_name->accept(*this);

   817     s4o.print("\n" + s4o.indent_spaces);

   818   }

   819 

   820   /* (A) Class (__configuration) declaration... */

   822   s4o.print("// CONFIGURATION\n" + s4o.indent_spaces);

   951   s4o.print("// CONFIGURATION ");

   823   s4o.print("class ");

   825   s4o.print(" {\n");

   953   s4o.print("\n");

   826   s4o.indent_right();

   954   

   827 

   955   /* (A.2) Global variables */

   828   /* (A.2) Global variables

   829    *    AND

   830    * (A.3) Programs in the Configuration

   831    */

   832   /* Programs types are mapped onto classes,

   833    * and programs are then instantiated inside the configuration

   834    * as objects of the appropriate class!

   835    */

   836   s4o.print(s4o.indent_spaces + "private:\n");

   837   s4o.indent_right();

   840   				      generate_cc_vardecl_c::global_vt |

   958   				      generate_cc_vardecl_c::global_vt);

   841 				      generate_cc_vardecl_c::program_vt |

   842   				      generate_cc_vardecl_c::resource_vt);

   848 

   963   /* (B) Initialisation Function */

   849 

   964   /* (B.1) Ressources initialisation protos... */

   850   /* (B) Constructor */

   965   wanted_declaretype = initprotos_dt;

   851   /* (B.1) Constructor name... */

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

   852   s4o.print(s4o.indent_spaces + "public:\n");

   967   s4o.print("\n");

   968   

   969   /* (B.2) Initialisation function name... */

   970   s4o.print(s4o.indent_spaces + "void config");

   971   s4o.print(FB_INIT_SUFFIX);

   972   s4o.print("(void) {\n");

   854   s4o.print(s4o.indent_spaces);

   974   

   855   symbol->configuration_name->accept(*this);

   975   /* (B.3) Global variables initializations... */

   856   s4o.print("(void)\n");

   857 

   858   /* (B.2) Member initializations... */

   859   s4o.indent_right();

   863 				      generate_cc_vardecl_c::program_vt |

   979   				      generate_cc_vardecl_c::global_vt);

   864   				      generate_cc_vardecl_c::global_vt |

   865   				      generate_cc_vardecl_c::resource_vt);

   868 

   982   s4o.print("\n");

   869   /* (B.3) Constructor Body... */

   983   

   870   s4o.print("\n" + s4o.indent_spaces + "{}\n\n");

   984   /* (B.3) Resources initializations... */

   985   wanted_declaretype = initdeclare_dt;

   986   symbol->resource_declarations->accept(*this);

   987   

   873 

  1010   s4o.print(s4o.indent_spaces + "}\n");

   874   /* (C) Public Function*/

   875   /* (C.1) Public Function declaration */

   876   s4o.print(s4o.indent_spaces + "public:\n");

   877   s4o.indent_right();

   878   s4o.print(s4o.indent_spaces + "void run(void) {\n");

   879 

   880   /* (C.2) Public Function body */

   881   /* Invoke each program in the configuration */

   882   s4o.indent_right();

   883   generate_cc_configbody_c *configbody = new generate_cc_configbody_c(&s4o);

   884   symbol->accept(*configbody);

   885   delete configbody;

   886   s4o.indent_left();

   887 

   888   /* (C.3) Close Public Function body */

   889   s4o.print(s4o.indent_spaces + "} /* f() */\n\n");

   890   s4o.indent_left();

   891 

   892   /* (D) Close the class declaration... */

   893   s4o.indent_left();

   894   s4o.print(s4o.indent_spaces + "}; /* class ");

   895   symbol->configuration_name->accept(*this);

   896 

   897   s4o.print(" */\n\n\n");

   901     

  1014 

  1015 void *visit(resource_declaration_c *symbol) {

  1016   if (wanted_declaretype == initprotos_dt || wanted_declaretype == runprotos_dt) {

  1017     s4o.print(s4o.indent_spaces + "void ");

  1018     symbol->resource_name->accept(*this);

  1019     if (wanted_declaretype == initprotos_dt) {

  1020       s4o.print(FB_INIT_SUFFIX);

  1021       s4o.print("(void);\n");

  1022     }

  1023     else {

  1024       s4o.print(FB_RUN_SUFFIX);

  1025       s4o.print("(int tick);\n");

  1026     }

  1027   }

  1028   if (wanted_declaretype == initdeclare_dt || wanted_declaretype == rundeclare_dt) {

  1029     s4o.print(s4o.indent_spaces);

  1030     symbol->resource_name->accept(*this);

  1031     if (wanted_declaretype == initdeclare_dt) {

  1032       s4o.print(FB_INIT_SUFFIX);

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

  1034     }

  1035     else {

  1036       s4o.print(FB_RUN_SUFFIX);

  1037       s4o.print("(tick);\n");

  1038     }

  1039   }

  1040   return NULL;

  1041 }

  1042 

  1043 void *visit(single_resource_declaration_c *symbol) {

  1044   if (wanted_declaretype == initprotos_dt || wanted_declaretype == runprotos_dt) {

  1045     s4o.print(s4o.indent_spaces + "void RESOURCE");

  1046     if (wanted_declaretype == initprotos_dt) {

  1047       s4o.print(FB_INIT_SUFFIX);

  1048       s4o.print("(void);\n");

  1049     }

  1050     else {

  1051       s4o.print(FB_RUN_SUFFIX);

  1052       s4o.print("(int tick);\n");

  1053     }

  1054   }

  1055   if (wanted_declaretype == initdeclare_dt || wanted_declaretype == rundeclare_dt) {

  1056     s4o.print(s4o.indent_spaces + "RESOURCE");

  1057     if (wanted_declaretype == initdeclare_dt) {

  1058       s4o.print(FB_INIT_SUFFIX);

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

  1060     }

  1061     else {

  1062       s4o.print(FB_RUN_SUFFIX);

  1063       s4o.print("(tick);\n");

  1064     }

  1065   }

  1066   return NULL;

  1067 }

  1068 

   917     generate_cc_resources_c(stage4out_c *s4o_ptr)

  1092     generate_cc_resources_c(stage4out_c *s4o_ptr, symbol_c *config_scope, symbol_c *resource_scope, unsigned long time)

   918       : generate_cc_typedecl_c(s4o_ptr) {};

  1093       : generate_cc_typedecl_c(s4o_ptr) {

   919     virtual ~generate_cc_resources_c(void) {}

  1094       search_config_instance = new search_var_instance_decl_c(config_scope);

   920 

  1095       search_resource_instance = new search_var_instance_decl_c(resource_scope);

  1096       common_ticktime = time;

  1097       current_resource_name = NULL;

  1098       current_global_vars = NULL;

  1099     };

  1100     virtual ~generate_cc_resources_c(void) {

  1101       delete search_config_instance;

  1102       delete search_resource_instance;

  1103     }

  1104 

  1105     typedef enum {

  1106       declare_dt,

  1107       init_dt,

  1108       run_dt

  1109     } declaretype_t;

  1110 

  1111     declaretype_t wanted_declaretype;

  1112 

  1113     unsigned long common_ticktime;

  1114     

  1115     const char *current_program_name;

  1116 

  1117     typedef enum {

  1118       assign_at,

  1119       send_at

  1120     } assigntype_t;

  1121 

  1122     assigntype_t wanted_assigntype;

  1123 

  1124 /********************************/

  1125 /* B 1.7 Configuration elements */

  1126 /********************************/

  1127 

  1128 /*

  1129 RESOURCE resource_name ON resource_type_name

  1130    optional_global_var_declarations

  1131    single_resource_declaration

  1132 END_RESOURCE

  1133 */

  1134 // SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration)

   922     	return NULL;

  1136       current_resource_name = symbol->resource_name;

   923     }

  1137       current_global_vars = symbol->global_var_declarations;

   924 

  1138       

  1139       symbol->resource_declaration->accept(*this);

  1140       

  1141       current_resource_name = NULL;

  1142       current_global_vars = NULL;

  1143       return NULL;

  1144     }

  1145 

  1146 /* task_configuration_list program_configuration_list */

  1147 // SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list)

   926     	return NULL;

  1149     	bool single_resource = current_resource_name == NULL;

   927     }

  1150       if (single_resource)

   928     

  1151         current_resource_name = new identifier_c("RESOURCE");

  1152       generate_cc_vardecl_c *vardecl;

  1153       

  1154       /* (A) resource declaration... */

  1155       /* (A.1) resource name in comment */

  1156       s4o.print("// RESOURCE ");

  1157       current_resource_name->accept(*this);

  1158       s4o.print("\n");

  1159        

  1160       /* (A.2) POUs inclusion */

  1161       s4o.print("#include \"POUS.c\"\n\n");

  1162       

  1163       /* (A.3) Global variables... */

  1164       if (current_global_vars != NULL) {

  1165         vardecl = new generate_cc_vardecl_c(&s4o,

  1166                       generate_cc_vardecl_c::local_vf,

  1167                       generate_cc_vardecl_c::global_vt);

  1168         vardecl->print(symbol);

  1169         delete vardecl;

  1170       }

  1171       

  1172       /* (A.4) Resource programs declaration... */

  1173       wanted_declaretype = declare_dt;

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

  1175       s4o.print("\n");

  1176       

  1177       /* (B) resource initialisation function... */

  1178       /* (B.1) initialisation function name... */

  1179       s4o.print("void ");

  1180       current_resource_name->accept(*this);

  1181       s4o.print(FB_INIT_SUFFIX);

  1182       s4o.print("(void) {\n");

  1183       s4o.indent_right();

  1184       

  1185       /* (B.2) Global variables initialisations... */

  1186       if (current_global_vars != NULL) {

  1187         s4o.print(s4o.indent_spaces);

  1188         vardecl = new generate_cc_vardecl_c(&s4o,

  1189                       generate_cc_vardecl_c::constructorinit_vf,

  1190                       generate_cc_vardecl_c::global_vt);

  1191         vardecl->print(symbol);

  1192         delete vardecl;

  1193       }

  1194       

  1195       /* (B.3) Resource programs initialisations... */

  1196       wanted_declaretype = init_dt;

  1197       symbol->program_configuration_list->accept(*this);

  1198       

  1199       s4o.indent_left();

  1200       s4o.print("}\n\n");

  1201       

  1202       /* (C) Resource run function... */

  1203       /* (C.1) Run function name... */

  1204       s4o.print("void ");

  1205       current_resource_name->accept(*this);

  1206       s4o.print(FB_RUN_SUFFIX);

  1207       s4o.print("(int tick) {\n");

  1208       s4o.indent_right();

  1209       

  1210       /* (C.2) Task management... */

  1211       symbol->task_configuration_list->accept(*this);

  1212       

  1213       /* (C.3) Program run declaration... */

  1214       wanted_declaretype = run_dt;

  1215       symbol->program_configuration_list->accept(*this);

  1216       

  1217       s4o.indent_left();

  1218       s4o.print("}\n\n");

  1219       

  1220       if (single_resource)

  1221         delete current_resource_name;

  1222       return NULL;

  1223     }

  1224     

  1225 /*  PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */

  1226 //SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused)

  1227     void *visit(program_configuration_c *symbol) {

  1228       if (wanted_declaretype == declare_dt) {

  1229         s4o.print(s4o.indent_spaces);

  1230         symbol->program_type_name->accept(*this);

  1231         s4o.print(" ");

  1232         symbol->program_name->accept(*this);

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

  1234       }

  1235       if (wanted_declaretype == init_dt) {

  1236         s4o.print(s4o.indent_spaces);

  1237         symbol->program_type_name->accept(*this);

  1238         s4o.print(FB_INIT_SUFFIX);

  1239         s4o.print("(&");

  1240         symbol->program_name->accept(*this);

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

  1242       }

  1243       if (wanted_declaretype == run_dt) {

  1244         current_program_name = ((identifier_c*)(symbol->program_name))->value;

  1245         if (symbol->task_name != NULL) {

  1246           s4o.print(s4o.indent_spaces);

  1247           s4o.print("if (");

  1248           symbol->task_name->accept(*this);

  1249           s4o.print(") {\n");

  1250           s4o.indent_right(); 

  1251         }

  1252         

  1253         wanted_assigntype = assign_at;

  1254         symbol->prog_conf_elements->accept(*this);

  1255         

  1256         s4o.print(s4o.indent_spaces);

  1257         symbol->program_type_name->accept(*this);

  1258         s4o.print(FB_FUNCTION_SUFFIX);

  1259         s4o.print("(&");

  1260         symbol->program_name->accept(*this);

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

  1262         

  1263         wanted_assigntype = send_at;

  1264         symbol->prog_conf_elements->accept(*this);

  1265         

  1266         if (symbol->task_name != NULL) {

  1267           s4o.indent_left();

  1268           s4o.print(s4o.indent_spaces + "}\n");

  1269         }

  1270       }

  1271       return NULL;

  1272     }

  1273     

  1274 /*  TASK task_name task_initialization */

  1275 //SYM_REF2(task_configuration_c, task_name, task_initialization)

  1276     void *visit(task_configuration_c *symbol) {

  1277       s4o.print(s4o.indent_spaces + "int ");

  1278       symbol->task_name->accept(*this);

  1279       s4o.print(" = ");

  1280       symbol->task_initialization->accept(*this);

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

  1282       return NULL;

  1283     }

  1284     

  1285 /*  '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */

  1286 //SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused)

  1287     void *visit(task_initialization_c *symbol) {

  1288       if (symbol->interval_data_source != NULL) {

  1289         calculate_time_c calculate_time;

  1290         symbol->interval_data_source->accept(calculate_time);

  1291         unsigned long time = calculate_time.get_time();

  1292         if (time != 0) {

  1293           s4o.print("tick % ");

  1294           s4o.print_integer((int)(time / common_ticktime));

  1295         }

  1296         else

  1297           s4o.print("1");

  1298       }

  1299       else

  1300         s4o.print("1");

  1301       return NULL;

  1302     }

  1303 

  1304 /*  any_symbolic_variable ASSIGN prog_data_source */

  1305 //SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source)

  1306     void *visit(prog_cnxn_assign_c *symbol) {

  1307       if (wanted_assigntype == assign_at) {

  1308         symbol_c *var_decl;

  1309         unsigned int vartype = 0;

  1310         symbol_c *current_var_reference = ((global_var_reference_c *)(symbol->prog_data_source))->global_var_name;

  1311         var_decl = search_resource_instance->get_decl(current_var_reference);

  1312         if (var_decl == NULL) {

  1313           var_decl = search_config_instance->get_decl(current_var_reference);

  1314           if (var_decl == NULL)

  1315             ERROR;

  1316           else

  1317             vartype = search_config_instance->get_vartype();

  1318         }

  1319         else

  1320           vartype = search_resource_instance->get_vartype();

  1321         

  1322         s4o.print(s4o.indent_spaces + "{extern ");

  1323         var_decl->accept(*this);

  1324         s4o.print(" ");

  1325         symbol->prog_data_source->accept(*this);

  1326         s4o.print("; ");

  1327         s4o.print(current_program_name);

  1328         s4o.print(".");

  1329         symbol->symbolic_variable->accept(*this);

  1330         s4o.print(" = ");

  1331         if (vartype || search_var_instance_decl_c::global_vt)

  1332           s4o.print("*");

  1333         symbol->prog_data_source->accept(*this);

  1334         s4o.print(";}\n");

  1335       }

  1336       return NULL;

  1337     }

  1338 

  1339 /* any_symbolic_variable SENDTO data_sink */

  1340 //SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, data_sink)

  1341     void *visit(prog_cnxn_sendto_c *symbol) {

  1342       if (wanted_assigntype == send_at) {

  1343         symbol_c *var_decl;

  1344         unsigned int vartype = 0;

  1345         symbol_c *current_var_reference = ((global_var_reference_c *)(symbol->data_sink))->global_var_name;

  1346         var_decl = search_resource_instance->get_decl(current_var_reference);

  1347         if (var_decl == NULL) {

  1348           var_decl = search_config_instance->get_decl(current_var_reference);

  1349           if (var_decl == NULL)

  1350             ERROR;

  1351           else

  1352             vartype = search_config_instance->get_vartype();

  1353         }

  1354         else

  1355           vartype = search_resource_instance->get_vartype();

  1356         

  1357         s4o.print(s4o.indent_spaces);

  1358         s4o.print(s4o.indent_spaces + "{extern ");

  1359         var_decl->accept(*this);

  1360         s4o.print(" ");

  1361         symbol->data_sink->accept(*this);

  1362         s4o.print("; ");

  1363         if (vartype || search_var_instance_decl_c::global_vt)

  1364           s4o.print("*");

  1365         symbol->data_sink->accept(*this);

  1366         s4o.print(" = ");

  1367         s4o.print(current_program_name);

  1368         s4o.print(".");

  1369         symbol->symbolic_variable->accept(*this);

  1370         s4o.print("};\n");

  1371       }

  1372       return NULL;

  1373     }

  1374 

   950             generate_cc_pous(&pous_s4o) {}

  1401             pous_s4o("POUS", "c"),

  1402             generate_cc_pous(&pous_s4o) {

  1403       current_configuration = NULL;

  1404     }

   997     	symbol->configuration_name->accept(*this);

  1451   	  static int configuration_count = 0;

  1452   

  1453       if (configuration_count++) {

  1454         /* the first configuration is the one we will use!! */

  1455         ERROR;

  1456       }

  1457       

  1458       current_configuration = symbol;

  1459       

  1460       calculate_common_ticktime_c calculate_common_ticktime;

  1461       symbol->accept(calculate_common_ticktime);

  1462       common_ticktime = calculate_common_ticktime.get_ticktime();

  1463       s4o.print("common_ticktime : ");

  1464       s4o.print_integer((int)(common_ticktime / 1000000));

  1465       s4o.print("ms\n");

  1466       

  1467       symbol->configuration_name->accept(*this);

  1001     	return NULL;

  1471       symbol->resource_declarations->accept(*this);

  1472     	

  1473       current_configuration = NULL;

  1474       

  1475       return NULL;

  1007     	generate_cc_resources_c generate_cc_resources(&resources_s4o);

  1481       generate_cc_resources_c generate_cc_resources(&resources_s4o, current_configuration, symbol, common_ticktime);

  1013     	stage4out_c resources_s4o("resource", "c");

  1487     	stage4out_c resources_s4o("RESOURCE", "c");

  1014     	generate_cc_resources_c generate_cc_resources(&resources_s4o);

  1488       generate_cc_resources_c generate_cc_resources(&resources_s4o, current_configuration, symbol, common_ticktime);