1 /*

     2  * (c) 2007 Mario de Sousa, Laurent Bessard

     3  *

     4  * Offered to the public under the terms of the GNU General Public License

     5  * as published by the Free Software Foundation; either version 2 of the

     6  * License, or (at your option) any later version.

     7  *

     8  * This program is distributed in the hope that it will be useful, but

     9  * WITHOUT ANY WARRANTY; without even the implied warranty of

    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11  * Public License for more details.

    12  *

    13  * This code is made available on the understanding that it will not be

    14  * used in safety-critical situations without a full and competent review.

    15  */

    16 

    17 /*

    18  * An IEC 61131-3 IL and ST compiler.

    19  *

    20  * Based on the

    21  * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22  *

    23  */

    24 

    25 

    26 /*

    27  * Conversion of sfc networks (i.e. SFC code).

    28  *

    29  * This is part of the 4th stage that generates

    30  * a c++ source program equivalent to the SFC, IL and ST

    31  * code.

    32  */

    33 

    34 

    35 

    36 

    37 /***********************************************************************/

    38 /***********************************************************************/

    39 /***********************************************************************/

    40 /***********************************************************************/

    41 

    42 class generate_cc_sfc_stepdecl_c: public generate_cc_base_c {

    43   

    44   private:

    45     char step_number;

    46     

    47   public:

    48     generate_cc_sfc_stepdecl_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

    49     ~generate_cc_sfc_stepdecl_c(void) {}

    50     

    51     void reset_step_number(void) {step_number = 0;}

    52     char get_step_number(void) {return step_number;}

    53     void increment_step_number(void) {step_number++;}

    54     void print_step_number(void) {

    55       char str[10];

    56       sprintf(str, "%d", step_number);

    57       s4o.print(str);

    58     }

    59 

    60 /*********************************************/

    61 /* B.1.6  Sequential function chart elements */

    62 /*********************************************/

    63     

    64     void *visit(initial_step_c *symbol) {

    65       s4o.print("#define ");

    66       symbol->step_name->accept(*this);

    67       s4o.print(" ");

    68       print_step_number();

    69       s4o.print("\n");

    70       increment_step_number();

    71       return NULL;

    72     }

    73     

    74     void *visit(step_c *symbol) {

    75       s4o.print("#define ");

    76       symbol->step_name->accept(*this);

    77       s4o.print(" ");

    78       print_step_number();

    79       s4o.print("\n");

    80       increment_step_number();

    81       return NULL;

    82     }

    83 

    84     void *visit(transition_c *symbol) {return NULL;}

    85 

    86     void *visit(action_c *symbol) {return NULL;}

    87 

    88 }; /* generate_cc_sfc_stepdecl_c */

    89 

    90 

    91 

    92 

    93 /***********************************************************************/

    94 /***********************************************************************/

    95 /***********************************************************************/

    96 /***********************************************************************/

    97 

    98 class generate_cc_sfc_actiondecl_c: public generate_cc_base_c {

    99   

   100   private:

   101     char action_number;

   102     

   103   public:

   104     generate_cc_sfc_actiondecl_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

   105     ~generate_cc_sfc_actiondecl_c(void) {}

   106     

   107     void reset_action_number(void) {action_number = 0;}

   108     char get_action_number(void) {return action_number;}

   109     void increment_action_number(void) {action_number++;}

   110     void print_action_number(void) {

   111       char str[10];

   112       sprintf(str, "%d", action_number);

   113       s4o.print(str);

   114     }

   115 

   116 /*********************************************/

   117 /* B.1.6  Sequential function chart elements */

   118 /*********************************************/

   119     

   120     void *visit(initial_step_c *symbol) {return NULL;}

   121     

   122     void *visit(step_c *symbol) {return NULL;}

   123 

   124     void *visit(transition_c *symbol) {return NULL;}

   125 

   126     void *visit(action_c *symbol) {

   127       s4o.print("#define ");

   128       symbol->action_name->accept(*this);

   129       s4o.print(" ");

   130       print_action_number();

   131       s4o.print("\n");

   132       increment_action_number();

   133       return NULL;

   134     }

   135 

   136 }; /* generate_cc_sfc_actiondecl_c */

   137 

   138 

   139 

   140 /***********************************************************************/

   141 /***********************************************************************/

   142 /***********************************************************************/

   143 /***********************************************************************/

   144 

   145 class generate_cc_sfcdecl_c: public iterator_visitor_c {

   146   

   147   protected:

   148     stage4out_c &s4o;

   149   

   150   private:

   151     generate_cc_sfc_stepdecl_c *generate_cc_sfc_stepdecl;

   152     generate_cc_sfc_actiondecl_c *generate_cc_sfc_actiondecl;

   153 

   154   public:

   155     generate_cc_sfcdecl_c(stage4out_c *s4o_ptr) : s4o(*s4o_ptr) {

   156       generate_cc_sfc_stepdecl = new generate_cc_sfc_stepdecl_c(s4o_ptr);

   157       generate_cc_sfc_actiondecl = new generate_cc_sfc_actiondecl_c(s4o_ptr);

   158     }

   159 

   160     virtual ~generate_cc_sfcdecl_c(void) {

   161       delete generate_cc_sfc_stepdecl;

   162       delete generate_cc_sfc_actiondecl;

   163     }

   164 

   165   public:

   166 

   167 /*********************************************/

   168 /* B.1.6  Sequential function chart elements */

   169 /*********************************************/

   170 

   171     /*| sequential_function_chart sfc_network*/

   172     void *visit(sfc_network_c *symbol) {

   173       char i;

   174       

   175       /* generate step number definitions */

   176       s4o.print(s4o.indent_spaces + "// Steps declaration\n");

   177       generate_cc_sfc_stepdecl->reset_step_number();

   178       symbol->accept(*generate_cc_sfc_stepdecl);

   179       s4o.print("\n" + s4o.indent_spaces + "nb_steps = ");

   180       generate_cc_sfc_stepdecl->print_step_number();

   181       s4o.print(";\n" + s4o.indent_spaces + "STEP step_list[");

   182       generate_cc_sfc_stepdecl->print_step_number();

   183       s4o.print("] = {\n");

   184       s4o.indent_right();

   185       for (i = 0; i < generate_cc_sfc_stepdecl->get_step_number(); i++) {

   186         if (i == 0) {

   187           s4o.print(s4o.indent_spaces + "{1, 0, 0}");

   188         }

   189         else {

   190           s4o.print(",\n" + s4o.indent_spaces + "{0, 0, 0}");

   191         }

   192       }

   193       s4o.indent_left();  

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

   195       

   196       /* generate action number definitions */

   197       s4o.print(s4o.indent_spaces + "// Actions declaration\n");

   198       generate_cc_sfc_actiondecl->reset_action_number();

   199       symbol->accept(*generate_cc_sfc_actiondecl);

   200       s4o.print("\n" + s4o.indent_spaces + "nb_actions = ");

   201       generate_cc_sfc_actiondecl->print_action_number();

   202       s4o.print(";\n" + s4o.indent_spaces + "STEP step_list[");

   203       generate_cc_sfc_actiondecl->print_action_number();

   204       s4o.print("] = {\n");

   205       s4o.indent_right();

   206       for (i = 0; i < generate_cc_sfc_actiondecl->get_action_number(); i++) {

   207         if (i == 0) {

   208           s4o.print(s4o.indent_spaces + "{0, 0, 0, 0, 0, 0}");

   209         }

   210         else {

   211           s4o.print(",\n" + s4o.indent_spaces + "{0, 0, 0, 0, 0, 0}");

   212         }

   213       }

   214       s4o.indent_left();  

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

   216       

   217       return NULL;

   218     }

   219 

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

   221 /* B 2.1 Instructions and Operands */

   222 /***********************************/

   223 /*| instruction_list il_instruction */

   224     void *visit(instruction_list_c *symbol) {return NULL;}

   225 

   226 /***************************************/

   227 /* B.3 - Language ST (Structured Text) */

   228 /***************************************/

   229 /********************/

   230 /* B 3.2 Statements */

   231 /********************/

   232 void *visit(statement_list_c *symbol) {return NULL;}

   233 

   234 /* Remainder implemented in generate_cc_sfcdecl_c... */

   235 };