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

#include <list>

    35

    36

typedef struct

    37

{

    38

  transition_c *symbol;

    39

  int priority;

    40

  int index;

    41

} TRANSITION;

    42

    43

    44

    45

    46

    47

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

    48

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

    49

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

    50

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

    51

    52

class generate_c_sfc_elements_c: public generate_c_base_c {

    53

    54

  public:

    55

    typedef enum {

    56

      transitionlist_sg,

    57

      transitiontest_sg,

    58

      stepset_sg,

    59

      stepreset_sg,

    60

      actionassociation_sg,

    61

      actionbody_sg

    62

    } sfcgeneration_t;

    63

    64

  private:

    65

    generate_c_il_c *generate_c_il;

    66

    generate_c_st_c *generate_c_st;

    67

    generate_c_SFC_IL_ST_c *generate_c_code;

    68

    search_var_instance_decl_c *search_var_instance_decl;

    69

    70

    int transition_number;

    71

    std::list<TRANSITION> transition_list;

    72

    73

    symbol_c *current_step;

    74

    symbol_c *current_action;

    75

    76

    sfcgeneration_t wanted_sfcgeneration;

    77

    78

  public:

    79

    generate_c_sfc_elements_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)

    80

    : generate_c_base_c(s4o_ptr) {

    81

      generate_c_il = new generate_c_il_c(s4o_ptr, scope, variable_prefix);

    82

      generate_c_st = new generate_c_st_c(s4o_ptr, scope, variable_prefix);

    83

      generate_c_code = new generate_c_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix);

    84

      search_var_instance_decl = new search_var_instance_decl_c(scope);

    85

      this->set_variable_prefix(variable_prefix);

    86

    }

    87

    88

    ~generate_c_sfc_elements_c(void) {

    89

      delete generate_c_il;

    90

      delete generate_c_st;

    91

      delete generate_c_code;

    92

      delete search_var_instance_decl;

    93

    }

    94

    95

    void reset_transition_number(void) {transition_number = 0;}

    96

    97

    void generate(symbol_c *symbol, sfcgeneration_t generation_type) {

    98

      wanted_sfcgeneration = generation_type;

   100

      switch (wanted_sfcgeneration) {

   101

        case transitiontest_sg:

   102

          {

   103

            std::list<TRANSITION>::iterator pt;

   104

            for(pt = transition_list.begin(); pt != transition_list.end(); pt++) {

   105

              transition_number = pt->index;

   106

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

   107

            }

   108

          }

   109

          break;

   110

        default:

   111

          symbol->accept(*this);

   112

          break;

   113

      }

   114

    }

   115

   116

    void print_step_argument(symbol_c *step_name, const char* argument) {

   117

      print_variable_prefix();

   118

      s4o.print("step_list[");

   119

      s4o.print(SFC_STEP_ACTION_PREFIX);

   120

      step_name->accept(*this);

   121

      s4o.print("].");

   122

      s4o.print(argument);

   123

    }

   124

   125

    void print_action_argument(symbol_c *action_name, const char* argument) {

   126

      print_variable_prefix();

   127

      s4o.print("action_list[");

   128

      s4o.print(SFC_STEP_ACTION_PREFIX);

   129

      action_name->accept(*this);

   130

      s4o.print("].");

   131

      s4o.print(argument);

   132

    }      

   133

   134

    void print_transition_number(void) {

   135

      char str[10];

   136

      sprintf(str, "%d", transition_number);

   137

      s4o.print(str);

   138

    }

   139

   140

    void print_reset_step(symbol_c *step_name) {

   141

      s4o.print(s4o.indent_spaces);

   142

      print_step_argument(step_name, "state");

   143

      s4o.print(" = 0;\n");

   144

    }

   145

   146

    void print_set_step(symbol_c *step_name) {

   147

      s4o.print(s4o.indent_spaces);

   148

      print_step_argument(step_name, "state");

   149

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

   150

      print_step_argument(step_name, "elapsed_time");

   151

      s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");

   152

    }

   153

   154

    bool is_variable(symbol_c *symbol) {

   155

      /* we try to find the variable instance declaration, to determine its type... */

   156

      symbol_c *var_decl = search_var_instance_decl->get_decl(symbol);

   157

   158

      return var_decl != NULL;

   159

    }

   160

   161

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

   162

/* B.1.6  Sequential function chart elements */

   163

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

   164

   165

    void *visit(initial_step_c *symbol) {

   166

      switch (wanted_sfcgeneration) {

   167

        case actionassociation_sg:

   168

          if (((list_c*)symbol->action_association_list)->n > 0) {

   169

            s4o.print(s4o.indent_spaces + "// ");

   170

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

   171

            s4o.print(" action associations\n");

   172

            current_step = symbol->step_name;

   173

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

   174

            s4o.indent_right();

   175

            s4o.print(s4o.indent_spaces + "char activated = ");

   176

            print_step_argument(current_step, "state");

   177

            s4o.print(" && !");

   178

            print_step_argument(current_step, "prev_state");

   179

            s4o.print(";\n");

   180

            s4o.print(s4o.indent_spaces + "char desactivated = !");

   181

            print_step_argument(current_step, "state");

   182

            s4o.print(" && ");

   183

            print_step_argument(current_step, "prev_state");

   184

            s4o.print(";\n");

   185

            s4o.print(s4o.indent_spaces + "char active = ");

   186

            print_step_argument(current_step, "state");

   187

            s4o.print(";\n");

   188

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

   189

            s4o.indent_left();

   190

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

   191

          }

   192

          break;

   193

        default:

   194

          break;

   195

      }

   196

      return NULL;

   197

    }

   198

   199

    void *visit(step_c *symbol) {

   200

      switch (wanted_sfcgeneration) {

   201

        case actionassociation_sg:

   202

          if (((list_c*)symbol->action_association_list)->n > 0) {

   203

            s4o.print(s4o.indent_spaces + "// ");

   204

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

   205

            s4o.print(" action associations\n");

   206

            current_step = symbol->step_name;

   207

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

   208

            s4o.indent_right();

   209

            s4o.print(s4o.indent_spaces + "char activated = ");

   210

            print_step_argument(current_step, "state");

   211

            s4o.print(" && !");

   212

            print_step_argument(current_step, "prev_state");

   213

            s4o.print(";\n");

   214

            s4o.print(s4o.indent_spaces + "char desactivated = !");

   215

            print_step_argument(current_step, "state");

   216

            s4o.print(" && ");

   217

            print_step_argument(current_step, "prev_state");

   218

            s4o.print(";\n");

   219

            s4o.print(s4o.indent_spaces + "char active = ");

   220

            print_step_argument(current_step, "state");

   221

            s4o.print(";\n");

   222

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

   223

            s4o.indent_left();

   224

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

   225

          }

   226

          break;

   227

        default:

   228

          break;

   229

      }

   230

      return NULL;

   231

    }

   232

   233

    void *visit(transition_c *symbol) {

   234

      switch (wanted_sfcgeneration) {

   235

        case transitionlist_sg:

   236

          {

   237

            TRANSITION *transition;

   238

            transition = new TRANSITION;

   239

            transition->symbol = symbol;

   240

            transition->index = transition_number;

   241

            if (symbol->integer != NULL) {

   242

              transition->priority = atoi(((token_c *)symbol->integer)->value);

   243

              std::list<TRANSITION>::iterator pt = transition_list.begin();

   244

              while (pt != transition_list.end() && pt->priority <= transition->priority) {

   245

                pt++;

   246

              } 

   247

              transition_list.insert(pt, *transition);

   248

            } 

   249

            else {

   250

              transition->priority = 0;

   251

              transition_list.push_back(*transition);

   252

            }

   253

            transition_number++;

   254

          }

   255

          break;

   256

        case transitiontest_sg:

   257

          s4o.print(s4o.indent_spaces + "if (");

   258

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

   259

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

   260

          s4o.indent_right();

   261

   262

          // Calculate transition value

   265

          if (symbol->integer != NULL) {

   266

            s4o.print(s4o.indent_spaces + "if (");

   267

            print_variable_prefix();

   268

            s4o.print("transition_list[");

   269

            print_transition_number();

   270

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

   271

            s4o.indent_right();

   272

            wanted_sfcgeneration = stepreset_sg;

   273

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

   274

            wanted_sfcgeneration = transitiontest_sg;

   275

            s4o.indent_left();

   276

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

   277

          }

   278

          s4o.indent_left();

   279

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

   280

          s4o.indent_right();

   281

          s4o.print(s4o.indent_spaces);

   282

          print_variable_prefix();

   283

          s4o.print("transition_list[");

   284

          print_transition_number();

   285

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

   286

          s4o.indent_left();

   287

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

   288

          break;

   289

        case stepset_sg:

   290

          s4o.print(s4o.indent_spaces + "if (");

   291

          print_variable_prefix();

   292

          s4o.print("transition_list[");

   293

          print_transition_number();

   294

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

   295

          s4o.indent_right();

   296

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

   297

          s4o.indent_left();

   298

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

   299

          transition_number++;

   300

          break;

   301

        case stepreset_sg:

   302

          if (symbol->integer == NULL) {

   303

            s4o.print(s4o.indent_spaces + "if (");

   304

            print_variable_prefix();

   305

            s4o.print("transition_list[");

   306

            print_transition_number();

   307

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

   308

            s4o.indent_right();

   309

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

   310

            s4o.indent_left();

   311

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

   312

          }

   313

          transition_number++;

   314

          break;

   315

        default:

   316

          break;

   317

      }

   318

      return NULL;

   319

    }

   320

   353

    void *visit(action_c *symbol) {

   354

      switch (wanted_sfcgeneration) {

   355

        case actionbody_sg:

   356

          s4o.print(s4o.indent_spaces + "if(");

   357

          print_variable_prefix();

   358

          s4o.print("action_list[");

   359

          s4o.print(SFC_STEP_ACTION_PREFIX);

   360

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

   361

          s4o.print("].state) {");

   362

          s4o.indent_right();

   363

   364

          // generate action code

   365

          symbol->function_block_body->accept(*generate_c_code);

   366

   367

          s4o.indent_left();

   368

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

   369

          break;

   370

        default:

   371

          break;

   372

      }

   373

      return NULL;

   374

    }

   375

   376

    void *visit(steps_c *symbol) {

   377

      if (symbol->step_name != NULL) {

   378

        switch (wanted_sfcgeneration) {

   379

          case transitiontest_sg:

   380

            print_step_argument(symbol->step_name, "state");

   381

            break;

   382

          case stepset_sg:

   383

            print_set_step(symbol->step_name);

   384

            break;

   385

          case stepreset_sg:

   386

            print_reset_step(symbol->step_name);

   387

            break;

   388

          default:

   389

            break;

   390

        }

   391

      }

   392

      else if (symbol->step_name_list != NULL) {

   393

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

   394

      }  

   395

      return NULL;

   396

    }

   397

   398

    void *visit(step_name_list_c *symbol) {

   399

      switch (wanted_sfcgeneration) {

   400

        case transitiontest_sg:

   401

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

   402

            print_step_argument(symbol->elements[i], "state");

   403

            if (i < symbol->n - 1) {

   404

              s4o.print(" && ");

   405

            }

   406

          }

   407

          break;

   408

        case stepset_sg:

   409

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

   410

            print_set_step(symbol->elements[i]);

   411

          }

   412

          break;

   413

        case stepreset_sg:

   414

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

   415

            print_reset_step(symbol->elements[i]);

   416

          }

   417

          break;

   418

        default:

   419

          break;

   420

      }

   421

      return NULL;

   422

    }

   423

   424

    void *visit(action_association_list_c* symbol) {

   425

      switch (wanted_sfcgeneration) {

   426

        case actionassociation_sg:

   427

          print_list(symbol, "", "\n", "\n");

   428

          break;

   429

        default:

   430

          break;

   431

      }

   432

      return NULL;

   433

    }

   434

   435

    void *visit(action_association_c *symbol) {

   436

      switch (wanted_sfcgeneration) {

   437

        case actionassociation_sg:

   438

          if (symbol->action_qualifier != NULL) {

   439

            current_action = symbol->action_name;

   440

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

   441

          }

   442

          else {

   443

            s4o.print(s4o.indent_spaces + "if (");

   444

            print_step_argument(current_step, "state");

   445

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

   446

            s4o.indent_right();

   447

            s4o.print(s4o.indent_spaces);

   448

            print_action_argument(symbol->action_name, "state");

   449

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

   450

            s4o.indent_left();

   451

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

   452

          }

   453

          break;

   454

        default:

   455

          break;

   456

      }

   457

      return NULL;

   458

    }

   459

   460

    void *visit(action_qualifier_c *symbol) {

   461

      switch (wanted_sfcgeneration) {

   462

        case actionassociation_sg:

   463

          {

   464

            char *qualifier = (char *)symbol->action_qualifier->accept(*this);

   465

            s4o.print(s4o.indent_spaces + "if (");

   466

            if (strcmp(qualifier, "N") == 0) {

   467

              s4o.print("active");

   468

            }

   469

            if (strcmp(qualifier, "P") == 0 || strcmp(qualifier, "SD") == 0 || 

   470

                strcmp(qualifier, "DS") == 0 || strcmp(qualifier, "SL") == 0 || 

   471

                strcmp(qualifier, "S") == 0 || strcmp(qualifier, "R") == 0) {

   472

              s4o.print("activated");

   473

            }

   474

            if (strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) {

   475

              s4o.print("active && ");

   476

              print_step_argument(current_step, "elapsed_time");

   477

              if (strcmp(qualifier, "D") == 0) {

   478

                s4o.print(" >= ");

   479

              }

   480

              else {

   481

                s4o.print(" < ");

   482

              }

   483

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

   484

            }

   485

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

   486

            s4o.indent_right();

   487

            s4o.print(s4o.indent_spaces);

   488

            if (strcmp(qualifier, "N") == 0 || strcmp(qualifier, "P") == 0 ||

   489

                strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) {

   490

              print_action_argument(current_action, "state");

   491

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

   492

            }

   493

            if (strcmp(qualifier, "S") == 0) {

   494

              if (is_variable(current_action)) {

   495

                print_variable_prefix();

   496

                current_action->accept(*this);

   497

              }

   498

              else

   499

                print_action_argument(current_action, "set");

   500

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

   501

            }

   502

            if (strcmp(qualifier, "R") == 0) {

   503

              if (is_variable(current_action)) {

   504

                print_variable_prefix();

   505

                current_action->accept(*this);

   506

                s4o.print(" = 0;\n");

   507

              }

   508

              else {

   509

                print_action_argument(current_action, "reset");

   510

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

   511

              }

   512

            }

   513

            if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || 

   514

                strcmp(qualifier, "SL") == 0) {

   515

              if (strcmp(qualifier, "SL") == 0) {

   516

                print_action_argument(current_action, "reset_remaining_time");  

   517

              }

   518

              else {

   519

                print_action_argument(current_action, "set_remaining_time");

   520

              }

   521

              s4o.print(" = ");

   522

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

   523

              s4o.print(";\n");

   524

            }

   525

            s4o.indent_left();

   526

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

   527

            if (strcmp(qualifier, "DS") == 0) {