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

typedef struct

    35

{

    36

  transition_c *symbol;

    37

  int priority;

    38

  int index;

    39

} TRANSITION;

    40

    41

    42

    43

    44

    45

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

    46

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

    47

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

    48

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

    49

    50

class generate_c_sfc_elements_c: public generate_c_base_c {

    51

    52

  public:

    53

    typedef enum {

    54

      transitionlist_sg,

    55

      transitiontest_sg,

    56

      transitiontestdebug_sg,

    57

      stepset_sg,

    58

      stepreset_sg,

    59

      actionassociation_sg,

    60

      actionbody_sg

    61

    } sfcgeneration_t;

    62

    63

  private:

    64

    generate_c_il_c *generate_c_il;

    65

    generate_c_st_c *generate_c_st;

    66

    generate_c_SFC_IL_ST_c *generate_c_code;

    67

    search_var_instance_decl_c *search_var_instance_decl;

    68

    69

    int transition_number;

    70

    std::list<TRANSITION> transition_list;

    71

    72

    symbol_c *current_step;

    73

    symbol_c *current_action;

    74

    75

    sfcgeneration_t wanted_sfcgeneration;

    76

    77

  public:

    78

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

    79

    : generate_c_base_c(s4o_ptr) {

    80

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

    81

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

    82

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

    83

      search_var_instance_decl = new search_var_instance_decl_c(scope);

    84

      this->set_variable_prefix(variable_prefix);

    85

    }

    86

    87

    ~generate_c_sfc_elements_c(void) {

    88

      delete generate_c_il;

    89

      delete generate_c_st;

    90

      delete generate_c_code;

    91

      delete search_var_instance_decl;

    92

    }

    93

    94

    void reset_transition_number(void) {transition_number = 0;}

    95

    96

    void generate(symbol_c *symbol, sfcgeneration_t generation_type) {

    97

      wanted_sfcgeneration = generation_type;

    98

      switch (wanted_sfcgeneration) {

    99

        case transitiontest_sg:

   100

          {

   101

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

   102

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

   103

              transition_number = pt->index;

   104

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

   105

            }

   106

          }

   107

          break;

   108

        default:

   109

          symbol->accept(*this);

   110

          break;

   111

      }

   112

    }

   113

   114

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

   115

      print_variable_prefix();

   116

      s4o.print("__step_list[");

   117

      s4o.print(SFC_STEP_ACTION_PREFIX);

   118

      step_name->accept(*this);

   119

      s4o.print("].");

   120

      s4o.print(argument);

   121

    }

   122

   123

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

   124

      print_variable_prefix();

   125

      s4o.print("__action_list[");

   126

      s4o.print(SFC_STEP_ACTION_PREFIX);

   127

      action_name->accept(*this);

   128

      s4o.print("].");

   129

      s4o.print(argument);

   130

    }      

   131

   132

    void print_transition_number(void) {

   133

      char str[10];

   134

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

   135

      s4o.print(str);

   136

    }

   137

   138

    void print_reset_step(symbol_c *step_name) {

   139

      s4o.print(s4o.indent_spaces);

   140

      print_step_argument(step_name, "state");

   141

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

   142

    }

   143

   144

    void print_set_step(symbol_c *step_name) {

   145

      s4o.print(s4o.indent_spaces);

   146

      print_step_argument(step_name, "state");

   147

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

   148

      print_step_argument(step_name, "elapsed_time");

   149

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

   150

    }

   151

   152

    bool is_variable(symbol_c *symbol) {

   153

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

   154

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

   155

   156

      return var_decl != NULL;

   157

    }

   158

   159

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

   160

/* B.1.6  Sequential function chart elements */

   161

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

   162

   163

    void *visit(initial_step_c *symbol) {

   164

      switch (wanted_sfcgeneration) {

   165

        case actionassociation_sg:

   166

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

   167

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

   168

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

   169

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

   170

            current_step = symbol->step_name;

   171

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

   172

            s4o.indent_right();

   173

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

   174

            print_step_argument(current_step, "state");

   175

            s4o.print(" && !");

   176

            print_step_argument(current_step, "prev_state");

   177

            s4o.print(";\n");

   178

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

   179

            print_step_argument(current_step, "state");

   180

            s4o.print(" && ");

   181

            print_step_argument(current_step, "prev_state");

   182

            s4o.print(";\n");

   183

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

   184

            print_step_argument(current_step, "state");

   185

            s4o.print(";\n");

   186

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

   187

            s4o.indent_left();

   188

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

   189

          }

   190

          break;

   191

        default:

   192

          break;

   193

      }

   194

      return NULL;

   195

    }

   196

   197

    void *visit(step_c *symbol) {

   198

      switch (wanted_sfcgeneration) {

   199

        case actionassociation_sg:

   200

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

   201

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

   202

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

   203

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

   204

            current_step = symbol->step_name;

   205

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

   206

            s4o.indent_right();

   207

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

   208

            print_step_argument(current_step, "state");

   209

            s4o.print(" && !");

   210

            print_step_argument(current_step, "prev_state");

   211

            s4o.print(";\n");

   212

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

   213

            print_step_argument(current_step, "state");

   214

            s4o.print(" && ");

   215

            print_step_argument(current_step, "prev_state");

   216

            s4o.print(";\n");

   217

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

   218

            print_step_argument(current_step, "state");

   219

            s4o.print(";\n");

   220

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

   221

            s4o.indent_left();

   222

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

   223

          }

   224

          break;

   225

        default:

   226

          break;

   227

      }

   228

      return NULL;

   229

    }

   230

   231

    void *visit(transition_c *symbol) {

   232

      switch (wanted_sfcgeneration) {

   233

        case transitionlist_sg:

   234

          {

   235

            TRANSITION *transition;

   236

            transition = new TRANSITION;

   237

            transition->symbol = symbol;

   238

            transition->index = transition_number;

   239

            if (symbol->integer != NULL) {

   240

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

   241

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

   242

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

   243

                pt++;

   244

              } 

   245

              transition_list.insert(pt, *transition);

   246

            } 

   247

            else {

   248

              transition->priority = 0;

   249

              transition_list.push_back(*transition);

   250

            }

   251

            transition_number++;

   252

          }

   253

          break;

   254

        case transitiontest_sg:

   255

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

   256

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

   257

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

   258

          s4o.indent_right();

   259

   260

          // Calculate transition value

   261

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

   262

   263

          if (symbol->integer != NULL) {

   264

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

   265

            print_variable_prefix();

   266

            s4o.print("__transition_list[");

   267

            print_transition_number();

   268

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

   269

            s4o.indent_right();

   270

            wanted_sfcgeneration = stepreset_sg;

   271

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

   272

            wanted_sfcgeneration = transitiontest_sg;

   273

            s4o.indent_left();

   274

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

   275

          }

   276

          s4o.indent_left();

   277

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

   278

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

   279

          s4o.indent_right();

   280

          // Calculate transition value for debug

   281

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

   282

          s4o.indent_right();

   283

          wanted_sfcgeneration = transitiontestdebug_sg;

   284

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

   285

          wanted_sfcgeneration = transitiontest_sg;

   286

          s4o.indent_left();

   287

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

   288

          s4o.print(s4o.indent_spaces);

   289

          print_variable_prefix();

   290

          s4o.print("__transition_list[");

   291

          print_transition_number();

   292

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

   293

          s4o.indent_left();

   294

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

   295

          break;

   296

        case stepset_sg:

   297

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

   298

          print_variable_prefix();

   299

          s4o.print("__transition_list[");

   300

          print_transition_number();

   301

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

   302

          s4o.indent_right();

   303

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

   304

          s4o.indent_left();

   305

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

   306

          transition_number++;

   307

          break;

   308

        case stepreset_sg:

   309

          if (symbol->integer == NULL) {

   310

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

   311

            print_variable_prefix();

   312

            s4o.print("__transition_list[");

   313

            print_transition_number();

   314

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

   315

            s4o.indent_right();

   316

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

   317

            s4o.indent_left();

   318

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

   319

          }

   320

          transition_number++;

   321

          break;

   322

        default:

   323

          break;

   324

      }

   325

      return NULL;

   326

    }

   327

   328

    void *visit(transition_condition_c *symbol) {

   329

      switch (wanted_sfcgeneration) {

   330

        case transitiontest_sg:

   331

        case transitiontestdebug_sg:

   332

          // Transition condition is in IL

   333

          if (symbol->transition_condition_il != NULL) {

   334

            generate_c_il->declare_backup_variable();

   335

            s4o.print(s4o.indent_spaces);

   336

            symbol->transition_condition_il->accept(*generate_c_il);

   337

            print_variable_prefix();

   338

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   339

              s4o.print("__debug_");

   340

            else

   341

              s4o.print("__");

   342

            s4o.print("transition_list[");

   343

            print_transition_number();

   344

            s4o.print("] = ");

   345

            generate_c_il->print_backup_variable();

   346

            s4o.print(";\n");

   347

          }

   348

          // Transition condition is in ST

   349

          if (symbol->transition_condition_st != NULL) {

   350

            s4o.print(s4o.indent_spaces);

   351

            print_variable_prefix();

   352

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   353

              s4o.print("__debug_");

   354

            else

   355

              s4o.print("__");

   356

            s4o.print("transition_list[");

   357

            print_transition_number();

   358

            s4o.print("] = ");

   359

            symbol->transition_condition_st->accept(*generate_c_st);

   360

            s4o.print(";\n");

   361

          }

   362

          if (wanted_sfcgeneration == transitiontest_sg) {

   363

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

   364

            s4o.indent_right();

   365

            s4o.print(s4o.indent_spaces);

   366

            print_variable_prefix();

   367

            s4o.print("__debug_transition_list[");

   368

            print_transition_number();

   369

            s4o.print("] = ");

   370

            print_variable_prefix();

   371

            s4o.print("__transition_list[");

   372

            print_transition_number();

   373

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

   374

            s4o.indent_left();

   375

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

   376

          }

   377

          break;

   378

        default:

   379

          break;

   380

      }

   381

      return NULL;

   382

    }

   383

   384

    void *visit(action_c *symbol) {

   385

      switch (wanted_sfcgeneration) {

   386

        case actionbody_sg:

   387

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

   388

          print_variable_prefix();

   389

          s4o.print("__action_list[");

   390

          s4o.print(SFC_STEP_ACTION_PREFIX);

   391

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

   392

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

   393

          s4o.indent_right();

   394

   395

          // generate action code

   396

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

   397

   398

          s4o.indent_left();

   399

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

   400

          break;

   401

        default:

   402

          break;

   403

      }

   404

      return NULL;

   405

    }

   406

   407

    void *visit(steps_c *symbol) {

   408

      if (symbol->step_name != NULL) {

   409

        switch (wanted_sfcgeneration) {

   410

          case transitiontest_sg:

   411

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

   412

            break;

   413

          case stepset_sg:

   414

            print_set_step(symbol->step_name);

   415

            break;

   416

          case stepreset_sg:

   417

            print_reset_step(symbol->step_name);

   418

            break;

   419

          default:

   420

            break;

   421

        }

   422

      }

   423

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

   424

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

   425

      }  

   426

      return NULL;

   427

    }

   428

   429

    void *visit(step_name_list_c *symbol) {

   430

      switch (wanted_sfcgeneration) {

   431

        case transitiontest_sg:

   432

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

   433

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

   434

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

   435

              s4o.print(" && ");

   436

            }

   437

          }

   438

          break;

   439

        case stepset_sg:

   440

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

   441

            print_set_step(symbol->elements[i]);

   442

          }

   443

          break;

   444

        case stepreset_sg:

   445

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

   446

            print_reset_step(symbol->elements[i]);

   447

          }

   448

          break;

   449

        default:

   450

          break;

   451

      }

   452

      return NULL;

   453

    }

   454

   455

    void *visit(action_association_list_c* symbol) {

   456

      switch (wanted_sfcgeneration) {

   457

        case actionassociation_sg:

   458

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

   459

          break;

   460

        default:

   461

          break;

   462

      }

   463

      return NULL;

   464

    }

   465

   466

    void *visit(action_association_c *symbol) {

   467

      switch (wanted_sfcgeneration) {

   468

        case actionassociation_sg:

   469

          if (symbol->action_qualifier != NULL) {

   470

            current_action = symbol->action_name;

   471

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

   472

          }

   473

          else {

   474

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

   475

            print_step_argument(current_step, "state");

   476

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

   477

            s4o.indent_right();

   478

            s4o.print(s4o.indent_spaces);

   479

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

   480

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

   481

            s4o.indent_left();

   482

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

   483

          }

   484

          break;

   485

        default:

   486

          break;

   487

      }

   488

      return NULL;

   489

    }

   490

   491

    void *visit(action_qualifier_c *symbol) {

   492

      switch (wanted_sfcgeneration) {

   493

        case actionassociation_sg:

   494

          {

   495

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

   496

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

   497

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

   498

              s4o.print("active");

   499

            }

   500

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

   501

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

   502

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

   503

              s4o.print("activated");

   504

            }

   505

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

   506

              s4o.print("active && __TIME_CMP(");

   507

              print_step_argument(current_step, "elapsed_time");

   508

              s4o.print(", ");

   509

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

   510

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

   511

                s4o.print(") >= 0");

   512

              }

   513

              else {

   514

                s4o.print(") < 0");

   515

              }

   516

            }

   517

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

   518

            s4o.indent_right();

   519

            s4o.print(s4o.indent_spaces);

   520

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

   521

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