Mercurial Mercurial > matiec / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
stage4/generate_cc/generate_cc.cc
changeset 17 38754701ac41
parent 16 e8b99f896416
child 18 e6af5eb5f546
equal deleted inserted replaced
16:e8b99f896416 17:38754701ac41 
   178 #include "search_varfb_instance_type.cc"
 
   178 #include "search_varfb_instance_type.cc"
 
   179 #include "search_constant_type.cc"
 
   179 #include "search_constant_type.cc"
 
   180 #include "search_expression_type.cc"
 
   180 #include "search_expression_type.cc"
 
   181 
   181 
   182 #include "generate_cc_base.cc"
 
   182 #include "generate_cc_base.cc"
 
       
   183 #include "generate_cc_sfcdecl.cc"
 
   183 #include "generate_cc_typedecl.cc"
 
   184 #include "generate_cc_typedecl.cc"
 
   184 #include "generate_cc_vardecl.cc"
 
   185 #include "generate_cc_vardecl.cc"
 
   185 #include "generate_cc_configbody.cc"
 
   186 #include "generate_cc_configbody.cc"
 
   186 
   187 
   187 /***********************************************************************/
 
   188 /***********************************************************************/
 
   211 /***********************************************************************/
 
   212 /***********************************************************************/
 
   212 /***********************************************************************/
 
   213 /***********************************************************************/
 
   213 /***********************************************************************/
 
   214 /***********************************************************************/
 
   214 
   215 
   215 /* A helper class that knows how to generate code for both the IL and ST languages... */
 
   216 /* A helper class that knows how to generate code for both the IL and ST languages... */
 
   216 class generate_cc_IL_and_ST_c: public null_visitor_c {
 
   217 class generate_cc_SFC_IL_ST_c: public null_visitor_c {
 
   217   private:
 
   218   private:
 
   218     stage4out_c *s4o_ptr;
 
   219     stage4out_c *s4o_ptr;
 
   219     symbol_c *scope;
 
   220     symbol_c *scope;
 
   220     const char *variable_prefix;
 
   221     const char *variable_prefix;
 
   221 
   222 
   222   public:
 
   223   public:
 
   223     generate_cc_IL_and_ST_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) {
 
   224     generate_cc_SFC_IL_ST_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL);
 
   224       if (NULL == scope) ERROR;
 
   225     /*********************************************/
 
   225       this->s4o_ptr = s4o_ptr;
 
   226     /* B.1.6  Sequential function chart elements */
 
   226       this->scope = scope;
 
   227     /*********************************************/
 
   227       this->variable_prefix = variable_prefix;
 
   228     
   228     }
 
   229     /*| sequential_function_chart sfc_network*/
 
   229 
   230     void *visit(sequential_function_chart_c * symbol);
 
   230 
   231     
   231   public:
 
   232     /****************************************/
 
   232 /****************************************/
 
   233     /* B.2 - Language IL (Instruction List) */
 
   233 /* B.2 - Language IL (Instruction List) */
 
   234     /****************************************/
 
   234 /****************************************/
 
   235     
   235 
   236     /***********************************/
 
   236 /***********************************/
 
   237     /* B 2.1 Instructions and Operands */
 
   237 /* B 2.1 Instructions and Operands */
 
   238     /***********************************/
 
   238 /***********************************/
 
   239     /*| instruction_list il_instruction */
 
   239 /*| instruction_list il_instruction */
 
   240     void *visit(instruction_list_c *symbol);
 
   240 void *visit(instruction_list_c *symbol) {
 
   241     
       
   242     /* Remainder implemented in generate_cc_il_c... */
 
       
   243     
       
   244     /***************************************/
 
       
   245     /* B.3 - Language ST (Structured Text) */
 
       
   246     /***************************************/
 
       
   247     /***********************/
 
       
   248     /* B 3.1 - Expressions */
 
       
   249     /***********************/
 
       
   250     /* Implemented in generate_cc_st_c */
 
       
   251     
       
   252     /********************/
 
       
   253     /* B 3.2 Statements */
 
       
   254     /********************/
 
       
   255     void *visit(statement_list_c *symbol);
 
       
   256 
       
   257 /* Remainder implemented in generate_cc_st_c... */
 
       
   258 };
 
       
   259 
       
   260 #include "generate_cc_sfc.cc"
 
       
   261 
       
   262 generate_cc_SFC_IL_ST_c::generate_cc_SFC_IL_ST_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix) {
 
       
   263   if (NULL == scope) ERROR;
 
       
   264   this->s4o_ptr = s4o_ptr;
 
       
   265   this->scope = scope;
 
       
   266   this->variable_prefix = variable_prefix;
 
       
   267 }
 
       
   268 
       
   269 void *generate_cc_SFC_IL_ST_c::visit(sequential_function_chart_c * symbol) {
 
       
   270   generate_cc_sfc_c generate_cc_sfc(s4o_ptr, scope, variable_prefix);
 
       
   271   generate_cc_sfc.generate(symbol);
 
       
   272   return NULL;
 
       
   273 }
 
       
   274 
       
   275 void *generate_cc_SFC_IL_ST_c::visit(instruction_list_c *symbol) {
 
   241   generate_cc_il_c generate_cc_il(s4o_ptr, scope, variable_prefix);
 
   276   generate_cc_il_c generate_cc_il(s4o_ptr, scope, variable_prefix);
 
   242   generate_cc_il.generate(symbol);
 
   277   generate_cc_il.generate(symbol);
 
   243   return NULL;
 
   278   return NULL;
 
   244 }
 
   279 }
 
   245 
   280 
   246 /* Remainder implemented in generate_cc_il_c... */
 
   281 void *generate_cc_SFC_IL_ST_c::visit(statement_list_c *symbol) {
 
   247 
       
   248 /***************************************/
 
       
   249 /* B.3 - Language ST (Structured Text) */
 
       
   250 /***************************************/
 
       
   251 /***********************/
 
       
   252 /* B 3.1 - Expressions */
 
       
   253 /***********************/
 
       
   254 /* Implemented in generate_cc_st_c */
 
       
   255 
       
   256 /********************/
 
       
   257 /* B 3.2 Statements */
 
       
   258 /********************/
 
       
   259 void *visit(statement_list_c *symbol) {
 
       
   260   generate_cc_st_c generate_cc_st(s4o_ptr, scope, variable_prefix);
 
   282   generate_cc_st_c generate_cc_st(s4o_ptr, scope, variable_prefix);
 
   261   generate_cc_st.generate(symbol);
 
   283   generate_cc_st.generate(symbol);
 
   262   return NULL;
 
   284   return NULL;
 
   263 }
 
   285 }
 
   264 
       
   265 /* Remainder implemented in generate_cc_st_c... */
 
       
   266 };
 
       
   267 
       
   268 
   286 
   269 
   287 
   270 
   288 
   271 
   289 
   272 /***********************************************************************/
 
   290 /***********************************************************************/
 
   448     default_value->accept(*this);
 
   466     default_value->accept(*this);
 
   449   }
 
   467   }
 
   450   s4o.print(";\n\n");
 
   468   s4o.print(";\n\n");
 
   451 
   469 
   452   /* (C) Function body */
 
   470   /* (C) Function body */
 
   453   generate_cc_IL_and_ST_c generate_cc_code(&s4o, symbol);
 
   471   generate_cc_SFC_IL_ST_c generate_cc_code(&s4o, symbol);
 
   454   symbol->function_body->accept(generate_cc_code);
 
   472   symbol->function_body->accept(generate_cc_code);
 
   455   s4o.print(s4o.indent_spaces + "return ");
 
   473   s4o.print(s4o.indent_spaces + "return ");
 
   456   symbol->derived_function_name->accept(*this);
 
   474   symbol->derived_function_name->accept(*this);
 
   457   s4o.print(";\n");
 
   475   s4o.print(";\n");
 
   458   s4o.indent_left();
 
   476   s4o.indent_left();
 
   541   vardecl->print(symbol->var_declarations, NULL,  FB_FUNCTION_PARAM"->");
 
   559   vardecl->print(symbol->var_declarations, NULL,  FB_FUNCTION_PARAM"->");
 
   542   delete vardecl;
 
   560   delete vardecl;
 
   543   s4o.print("\n");
 
   561   s4o.print("\n");
 
   544 
   562 
   545   /* (B.3) Function code */
 
   563   /* (B.3) Function code */
 
   546   generate_cc_IL_and_ST_c generate_cc_code(&s4o, symbol, FB_FUNCTION_PARAM"->");
 
   564   generate_cc_SFC_IL_ST_c generate_cc_code(&s4o, symbol, FB_FUNCTION_PARAM"->");
 
   547   symbol->fblock_body->accept(generate_cc_code);
 
   565   symbol->fblock_body->accept(generate_cc_code);
 
   548   s4o.indent_left();
 
   566   s4o.indent_left();
 
   549   s4o.print(s4o.indent_spaces + "} // ");
 
   567   s4o.print(s4o.indent_spaces + "} // ");
 
   550   symbol->fblock_name->accept(*this);
 
   568   symbol->fblock_name->accept(*this);
 
   551   s4o.print(FB_FUNCTION_SUFFIX);
 
   569   s4o.print(FB_FUNCTION_SUFFIX);
 
   600   delete vardecl;
 
   618   delete vardecl;
 
   601   s4o.print("\n");
 
   619   s4o.print("\n");
 
   602   /* (A.3) Private internal variables */
 
   620   /* (A.3) Private internal variables */
 
   603   s4o.print(s4o.indent_spaces + "// PROGRAM private variables - TEMP, private and located variables\n");
 
   621   s4o.print(s4o.indent_spaces + "// PROGRAM private variables - TEMP, private and located variables\n");
 
   604   vardecl = new generate_cc_vardecl_c(&s4o,
 
   622   vardecl = new generate_cc_vardecl_c(&s4o,
 
   605   				      generate_cc_vardecl_c::local_vf,
 
   623                 generate_cc_vardecl_c::local_vf,
 
   606 				      generate_cc_vardecl_c::temp_vt |
 
   624                 generate_cc_vardecl_c::temp_vt |
 
   607   				      generate_cc_vardecl_c::private_vt |
 
   625                 generate_cc_vardecl_c::private_vt |
 
   608   				      generate_cc_vardecl_c::located_vt |
 
   626                 generate_cc_vardecl_c::located_vt |
 
   609   				      generate_cc_vardecl_c::external_vt);
 
   627                 generate_cc_vardecl_c::external_vt);
 
   610   vardecl->print(symbol->var_declarations);
 
   628   vardecl->print(symbol->var_declarations);
 
   611   delete vardecl;
 
   629   delete vardecl;
 
   612   s4o.print("\n");
 
   630   s4o.print("\n");
 
   613 
   631 
   614   /* (A.4) Program data structure type name. */
 
   632   /* (A.4) Generate private internal variables for SFC*/
 
       
   633   generate_cc_sfcdecl_c generate_cc_sfcdecl(&s4o);
 
       
   634   symbol->function_block_body->accept(generate_cc_sfcdecl);
 
       
   635 
       
   636   /* (A.5) Program data structure type name. */
 
   615   s4o.indent_left();
 
   637   s4o.indent_left();
 
   616   s4o.print("} ");
 
   638   s4o.print("} ");
 
   617   symbol->program_type_name->accept(*this);
 
   639   symbol->program_type_name->accept(*this);
 
   618   s4o.print(";\n\n");
 
   640   s4o.print(";\n\n");
 
   619 
   641 
   641   vardecl->print(symbol->var_declarations, NULL,  FB_FUNCTION_PARAM"->");
 
   663   vardecl->print(symbol->var_declarations, NULL,  FB_FUNCTION_PARAM"->");
 
   642   delete vardecl;
 
   664   delete vardecl;
 
   643   s4o.print("\n");
 
   665   s4o.print("\n");
 
   644 
   666 
   645   /* (B.3) Function code */
 
   667   /* (B.3) Function code */
 
   646   generate_cc_IL_and_ST_c generate_cc_code(&s4o, symbol, FB_FUNCTION_PARAM"->");
 
   668   generate_cc_SFC_IL_ST_c generate_cc_code(&s4o, symbol, FB_FUNCTION_PARAM"->");
 
   647   symbol->function_block_body->accept(generate_cc_code);
 
   669   symbol->function_block_body->accept(generate_cc_code);
 
   648   s4o.indent_left();
 
   670   s4o.indent_left();
 
   649   s4o.print(s4o.indent_spaces + "} // ");
 
   671   s4o.print(s4o.indent_spaces + "} // ");
 
   650   symbol->program_type_name->accept(*this);
 
   672   symbol->program_type_name->accept(*this);
 
   651   s4o.print(FB_FUNCTION_SUFFIX);
 
   673   s4o.print(FB_FUNCTION_SUFFIX);
matiec