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 */

   102

          s4o.print(s4o.indent_spaces + "BOOL __transition_list[");

   103

          s4o.print_integer(transition_number);

   104

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

   105

   106

          /* transitions debug table declaration */

   107

          s4o.print(s4o.indent_spaces + "BOOL __debug_transition_list[");

   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 */

   131

          s4o.print(s4o.indent_spaces + "STEP temp_step = {0, 0, 0};\n");

   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 */

   157

          s4o.print(s4o.indent_spaces + "ACTION temp_action = {0, 0, 0, 0, 0, 0};\n");

   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);

   211

          print_variable_prefix();

   212

          s4o.print("__step_list[");

   213

          s4o.print_integer(step_number);

   214

          s4o.print("].state = 1;\n");

   215

          step_number++;

   216

          break;

   217

        case stepdef_sd:

   218

          s4o.print("#define ");

   219

          s4o.print(SFC_STEP_ACTION_PREFIX);

   220

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

   221

          s4o.print(" ");

   222

          s4o.print_integer(step_number);

   223

          s4o.print("\n");

   224

          step_number++;

   225

          break;

   226

        case stepundef_sd:

   227

          s4o.print("#undef ");

   228

          s4o.print(SFC_STEP_ACTION_PREFIX);

   229

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

   230

          s4o.print("\n");

   231

          break;

   232

        default:

   233

          break;

   234

      }

   235

      return NULL;

   236

    }

   237

   238

    void *visit(step_c *symbol) {

   239

      switch (wanted_sfcdeclaration) {

   240

        case stepcount_sd:

   241

        case sfcdecl_sd:

   242

        case sfcinit_sd:

   243

          step_number++;

   244

          break;

   245

        case stepdef_sd:

   246

          s4o.print("#define ");

   247

          s4o.print(SFC_STEP_ACTION_PREFIX);

   248

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

   249

          s4o.print(" ");

   250

          s4o.print_integer(step_number);

   251

          s4o.print("\n");

   252

          step_number++;

   253

          break;

   254

        case stepundef_sd:

   255

          s4o.print("#undef ");

   256

          s4o.print(SFC_STEP_ACTION_PREFIX);

   257

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

   258

          s4o.print("\n");

   259

          break;

   260

        default:

   261

          break;

   262

      }

   263

      return NULL;

   264

    }

   265

   266

    void *visit(transition_c *symbol) {

   267

      switch (wanted_sfcdeclaration) {

   268

        case sfcdecl_sd:

   269

          transition_number++;

   270

          break;

   271

        default:

   272

          break;

   273

      }

   274

      return NULL;

   275

    }

   276

   277

    void *visit(action_c *symbol) {

   278

      switch (wanted_sfcdeclaration) {

   279

        case actiondef_sd:

   280

          s4o.print("#define ");

   281

          s4o.print(SFC_STEP_ACTION_PREFIX);

   282

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

   283

          s4o.print(" ");

   284

          s4o.print_integer(action_number);

   285

          s4o.print("\n");

   286

          action_number++;

   287

          break;

   288

        case actionundef_sd:

   289

          s4o.print("#undef ");

   290

          s4o.print(SFC_STEP_ACTION_PREFIX);

   291

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

   292

          s4o.print("\n");

   293

          break;

   294

        case actioncount_sd:

   295

        case sfcdecl_sd:

   296

          action_number++;

   297

          break;

   298

        default:

   299

          break;

   300

      }

   301

      return NULL;

   302

    }

   303

   304

    void *visit(instruction_list_c *symbol) {

   305

      return NULL;

   306

    }

   307

   308

    void *visit(statement_list_c *symbol) {

   309

      return NULL;

   310

    }

   311

   312

}; /* generate_c_sfcdecl_c */

   313