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_c_sfcdecl_c: protected generate_c_typedecl_c {

    43

    44

  public:

    45

      typedef enum {

    46

        sfcdecl_sd,

    47

        sfcinit_sd,

    48

        stepcount_sd,

    49

        stepdef_sd,

    50

        stepundef_sd,

    51

        actiondef_sd,

    52

        actionundef_sd,

    53

        actioncount_sd

    54

       } sfcdeclaration_t;

    55

    56

  private:

    57

    char step_number;

    58

    char action_number;

    59

    char transition_number;

    60

    61

    sfcdeclaration_t wanted_sfcdeclaration;

    62

    63

  public:

    64

    generate_c_sfcdecl_c(stage4out_c *s4o_ptr, sfcdeclaration_t sfcdeclaration)

    65

    : generate_c_typedecl_c(s4o_ptr) {

    66

      wanted_sfcdeclaration = sfcdeclaration;

    67

    }

    68

    ~generate_c_sfcdecl_c(void) {}

    69

    70

    void print(symbol_c *symbol, const char *variable_prefix = NULL) {

    71

      this->set_variable_prefix(variable_prefix);

    72

    73

      symbol->accept(*this);

    74

    }

    75

    76

/*********************************************/

    77

/* B.1.6  Sequential function chart elements */

    78

/*********************************************/

    79

    80

    void *visit(sequential_function_chart_c *symbol) {

    81

      step_number = 0;

    82

      action_number = 0;

    83

      transition_number = 0;

    84

      switch (wanted_sfcdeclaration) {

    85

        case sfcdecl_sd:

    86

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

    87

            symbol->elements[i]->accept(*this);

    88

    89

          /* steps table declaration */

    90

          s4o.print(s4o.indent_spaces + "STEP __step_list[");

    91

          s4o.print_integer(step_number);

    92

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

    93

          s4o.print(s4o.indent_spaces + "UINT __nb_steps;\n");

    94

    95

          /* actions table declaration */

    96

          s4o.print(s4o.indent_spaces + "ACTION __action_list[");

    97

          s4o.print_integer(action_number);

    98

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

    99

          s4o.print(s4o.indent_spaces + "UINT __nb_actions;\n");

   100

   101

          /* transitions table declaration */

   103

          s4o.print_integer(transition_number);

   104

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

   105

   106

          /* transitions debug table declaration */

   108

          s4o.print_integer(transition_number);

   109

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

   110

   111

          /* last_ticktime declaration */

   112

          s4o.print(s4o.indent_spaces + "TIME __lasttick_time;\n");

   113

          break;

   114

        case sfcinit_sd:

   115

          s4o.print(s4o.indent_spaces);

   116

          s4o.print("UINT i;\n");

   117

   118

          /* steps table count */

   119

          wanted_sfcdeclaration = stepcount_sd;

   120

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

   121

            symbol->elements[i]->accept(*this);

   122

          s4o.print(s4o.indent_spaces);

   123

          print_variable_prefix();

   124

          s4o.print("__nb_steps = ");

   125

          s4o.print_integer(step_number);

   126

          s4o.print(";\n");

   127

          step_number = 0;

   128

          wanted_sfcdeclaration = sfcinit_sd;

   129

   130

          /* steps table initialisation */

   132

          s4o.print(s4o.indent_spaces + "for(i = 0; i < ");

   133

          print_variable_prefix();

   134

          s4o.print("__nb_steps; i++) {\n");

   135

          s4o.indent_right();

   136

          s4o.print(s4o.indent_spaces);

   137

          print_variable_prefix();

   138

          s4o.print("__step_list[i] = temp_step;\n");

   139

          s4o.indent_left();

   140

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

   141

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

   142

            symbol->elements[i]->accept(*this);

   143

   144

          /* steps table count */

   145

          wanted_sfcdeclaration = actioncount_sd;

   146

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

   147

            symbol->elements[i]->accept(*this);

   148

          s4o.print(s4o.indent_spaces);

   149

          print_variable_prefix();

   150

          s4o.print("__nb_actions = ");

   151

          s4o.print_integer(action_number);

   152

          s4o.print(";\n");

   153

          action_number = 0;

   154

          wanted_sfcdeclaration = sfcinit_sd;

   155

   156

          /* actions table initialisation */

   158

          s4o.print(s4o.indent_spaces + "for(i = 0; i < ");

   159

          print_variable_prefix();

   160

          s4o.print("__nb_actions; i++) {\n");

   161

          s4o.indent_right();

   162

          s4o.print(s4o.indent_spaces);

   163

          print_variable_prefix();

   164

          s4o.print("__action_list[i] = temp_action;\n");

   165

          s4o.indent_left();

   166

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

   167

   168

          /* last_ticktime initialisation */

   169

          s4o.print(s4o.indent_spaces);

   170

          print_variable_prefix();

   171

          s4o.print("__lasttick_time = __CURRENT_TIME;\n");

   172

          break;

   173

        case stepdef_sd:

   174

          s4o.print("// Steps definitions\n");

   175

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

   176

            symbol->elements[i]->accept(*this);

   177

          s4o.print("\n");

   178

          break;

   179

        case actiondef_sd:

   180

          s4o.print("// Actions definitions\n");

   181

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

   182

            symbol->elements[i]->accept(*this);

   183

          s4o.print("\n");

   184

          break;

   185

        case stepundef_sd:

   186

          s4o.print("// Steps undefinitions\n");

   187

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

   188

            symbol->elements[i]->accept(*this);

   189

          s4o.print("\n");

   190

          break;

   191

        case actionundef_sd:

   192

          s4o.print("// Actions undefinitions\n");

   193

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

   194

            symbol->elements[i]->accept(*this);

   195

          s4o.print("\n");

   196

          break;

   197

        default:

   198

          break;

   199

      }

   200

      return NULL;

   201

    }

   202

   203

    void *visit(initial_step_c *symbol) {

   204

      switch (wanted_sfcdeclaration) {

   205

        case stepcount_sd:

   206

        case sfcdecl_sd:

   207

          step_number++;

   208

          break;

   209

        case sfcinit_sd:

   210

          s4o.print(s4o.indent_spaces);

   213

          print_variable_prefix();

   214

          s4o.print("__step_list[");

   215

          s4o.print_integer(step_number);

   217

          step_number++;

   218

          break;

   219

        case stepdef_sd:

   220

          s4o.print("#define ");

   221

          s4o.print(SFC_STEP_ACTION_PREFIX);

   222

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

   223

          s4o.print(" ");

   224

          s4o.print_integer(step_number);

   225

          s4o.print("\n");

   226

          step_number++;

   227

          break;

   228

        case stepundef_sd:

   229

          s4o.print("#undef ");

   230

          s4o.print(SFC_STEP_ACTION_PREFIX);

   231

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

   232

          s4o.print("\n");

   233

          break;

   234

        default:

   235

          break;

   236

      }

   237

      return NULL;

   238

    }

   239

   240

    void *visit(step_c *symbol) {

   241

      switch (wanted_sfcdeclaration) {

   242

        case stepcount_sd:

   243

        case sfcdecl_sd:

   244

        case sfcinit_sd:

   245

          step_number++;

   246

          break;

   247

        case stepdef_sd:

   248

          s4o.print("#define ");

   249

          s4o.print(SFC_STEP_ACTION_PREFIX);

   250

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

   251

          s4o.print(" ");

   252

          s4o.print_integer(step_number);

   253

          s4o.print("\n");

   254

          step_number++;

   255

          break;

   256

        case stepundef_sd:

   257

          s4o.print("#undef ");

   258

          s4o.print(SFC_STEP_ACTION_PREFIX);

   259

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

   260

          s4o.print("\n");

   261

          break;

   262

        default:

   263

          break;

   264

      }

   265

      return NULL;

   266

    }

   267

   268

    void *visit(transition_c *symbol) {

   269

      switch (wanted_sfcdeclaration) {

   270

        case sfcdecl_sd:

   271

          transition_number++;

   272

          break;

   273

        default:

   274

          break;

   275

      }

   276

      return NULL;

   277

    }

   278

   279

    void *visit(action_c *symbol) {

   280

      switch (wanted_sfcdeclaration) {

   281

        case actiondef_sd:

   282

          s4o.print("#define ");

   283

          s4o.print(SFC_STEP_ACTION_PREFIX);

   284

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

   285

          s4o.print(" ");

   286

          s4o.print_integer(action_number);

   287

          s4o.print("\n");

   288

          action_number++;

   289

          break;

   290

        case actionundef_sd:

   291

          s4o.print("#undef ");

   292

          s4o.print(SFC_STEP_ACTION_PREFIX);

   293

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

   294

          s4o.print("\n");

   295

          break;

   296

        case actioncount_sd:

   297

        case sfcdecl_sd:

   298

          action_number++;

   299

          break;

   300

        default:

   301

          break;

   302

      }

   303

      return NULL;

   304

    }

   305

   306

    void *visit(instruction_list_c *symbol) {

   307

      return NULL;

   308

    }

   309

   310

    void *visit(statement_list_c *symbol) {

   311

      return NULL;

   312

    }

   313

   314

}; /* generate_c_sfcdecl_c */

   315