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

      transition_list.clear();

    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;

    99

      switch (wanted_sfcgeneration) {

   100

        case transitiontest_sg:

   101

          {

   102

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

   103

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

   104

              transition_number = pt->index;

   105

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

   106

            }

   107

          }

   108

          break;

   109

        default:

   110

          symbol->accept(*this);

   111

          break;

   112

      }

   113

    }

   114

   115

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

   116

      print_variable_prefix();

   117

      s4o.print("__step_list[");

   118

      s4o.print(SFC_STEP_ACTION_PREFIX);

   119

      step_name->accept(*this);

   120

      s4o.print("].");

   121

      s4o.print(argument);

   122

    }

   123

   124

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

   125

      print_variable_prefix();

   126

      s4o.print("__action_list[");

   127

      s4o.print(SFC_STEP_ACTION_PREFIX);

   128

      action_name->accept(*this);

   129

      s4o.print("].");

   130

      s4o.print(argument);

   131

    }      

   132

   133

    void print_transition_number(void) {

   134

      char str[10];

   135

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

   136

      s4o.print(str);

   137

    }

   138

   139

    void print_reset_step(symbol_c *step_name) {

   140

      s4o.print(s4o.indent_spaces);

   141

      print_step_argument(step_name, "state");

   142

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

   143

    }

   144

   145

    void print_set_step(symbol_c *step_name) {

   146

      s4o.print(s4o.indent_spaces);

   147

      print_step_argument(step_name, "state");

   148

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

   149

      print_step_argument(step_name, "elapsed_time");

   150

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

   151

    }

   152

   153

    bool is_variable(symbol_c *symbol) {

   154

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

   155

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

   156

   157

      return var_decl != NULL;

   158

    }

   159

   160

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

   161

/* B.1.6  Sequential function chart elements */

   162

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

   163

   164

    void *visit(initial_step_c *symbol) {

   165

      switch (wanted_sfcgeneration) {

   166

        case actionassociation_sg:

   167

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

   168

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

   169

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

   170

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

   171

            current_step = symbol->step_name;

   172

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

   173

            s4o.indent_right();

   174

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

   175

            print_step_argument(current_step, "state");

   176

            s4o.print(" && !");

   177

            print_step_argument(current_step, "prev_state");

   178

            s4o.print(";\n");

   179

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

   180

            print_step_argument(current_step, "state");

   181

            s4o.print(" && ");

   182

            print_step_argument(current_step, "prev_state");

   183

            s4o.print(";\n");

   184

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

   185

            print_step_argument(current_step, "state");

   186

            s4o.print(";\n");

   187

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

   188

            s4o.indent_left();

   189

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

   190

          }

   191

          break;

   192

        default:

   193

          break;

   194

      }

   195

      return NULL;

   196

    }

   197

   198

    void *visit(step_c *symbol) {

   199

      switch (wanted_sfcgeneration) {

   200

        case actionassociation_sg:

   201

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

   202

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

   203

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

   204

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

   205

            current_step = symbol->step_name;

   206

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

   207

            s4o.indent_right();

   208

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

   209

            print_step_argument(current_step, "state");

   210

            s4o.print(" && !");

   211

            print_step_argument(current_step, "prev_state");

   212

            s4o.print(";\n");

   213

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

   214

            print_step_argument(current_step, "state");

   215

            s4o.print(" && ");

   216

            print_step_argument(current_step, "prev_state");

   217

            s4o.print(";\n");

   218

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

   219

            print_step_argument(current_step, "state");

   220

            s4o.print(";\n");

   221

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

   222

            s4o.indent_left();

   223

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

   224

          }

   225

          break;

   226

        default:

   227

          break;

   228

      }

   229

      return NULL;

   230

    }

   231

   232

    void *visit(transition_c *symbol) {

   233

      switch (wanted_sfcgeneration) {

   234

        case transitionlist_sg:

   235

          {

   236

            TRANSITION *transition;

   237

            transition = new TRANSITION;

   238

            transition->symbol = symbol;

   239

            transition->index = transition_number;

   240

            if (symbol->integer != NULL) {

   241

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

   242

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

   243

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

   244

                pt++;

   245

              } 

   246

              transition_list.insert(pt, *transition);

   247

            } 

   248

            else {

   249

              transition->priority = 0;

   250

              transition_list.push_back(*transition);

   251

            }

   252

            transition_number++;

   253

          }

   254

          break;

   255

        case transitiontest_sg:

   256

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

   257

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

   258

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

   259

          s4o.indent_right();

   260

   261

          // Calculate transition value

   262

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

   263

   264

          if (symbol->integer != NULL) {

   265

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

   266

            print_variable_prefix();

   267

            s4o.print("__transition_list[");

   268

            print_transition_number();

   269

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

   270

            s4o.indent_right();

   271

            wanted_sfcgeneration = stepreset_sg;

   272

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

   273

            wanted_sfcgeneration = transitiontest_sg;

   274

            s4o.indent_left();

   275

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

   276

          }

   277

          s4o.indent_left();

   278

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

   279

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

   280

          s4o.indent_right();

   281

          // Calculate transition value for debug

   282

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

   283

          s4o.indent_right();

   284

          wanted_sfcgeneration = transitiontestdebug_sg;

   285

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

   286

          wanted_sfcgeneration = transitiontest_sg;

   287

          s4o.indent_left();

   288

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

   289

          s4o.print(s4o.indent_spaces);

   290

          print_variable_prefix();

   291

          s4o.print("__transition_list[");

   292

          print_transition_number();

   293

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

   294

          s4o.indent_left();

   295

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

   296

          break;

   297

        case stepset_sg:

   298

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

   299

          print_variable_prefix();

   300

          s4o.print("__transition_list[");

   301

          print_transition_number();

   302

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

   303

          s4o.indent_right();

   304

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

   305

          s4o.indent_left();

   306

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

   307

          transition_number++;

   308

          break;

   309

        case stepreset_sg:

   310

          if (symbol->integer == NULL) {

   311

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

   312

            print_variable_prefix();

   313

            s4o.print("__transition_list[");

   314

            print_transition_number();

   315

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

   316

            s4o.indent_right();

   317

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

   318

            s4o.indent_left();

   319

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

   320

          }

   321

          transition_number++;

   322

          break;

   323

        default:

   324

          break;

   325

      }

   326

      return NULL;

   327

    }

   328

   329

    void *visit(transition_condition_c *symbol) {

   330

      switch (wanted_sfcgeneration) {

   331

        case transitiontest_sg:

   332

        case transitiontestdebug_sg:

   333

          // Transition condition is in IL

   334

          if (symbol->transition_condition_il != NULL) {

   335

            generate_c_il->declare_backup_variable();

   336

            s4o.print(s4o.indent_spaces);

   337

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

   338

            print_variable_prefix();

   339

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   340

              s4o.print("__debug_");

   341

            else

   342

              s4o.print("__");

   343

            s4o.print("transition_list[");

   344

            print_transition_number();

   345

            s4o.print("] = ");

   346

            generate_c_il->print_backup_variable();

   347

            s4o.print(";\n");

   348

          }

   349

          // Transition condition is in ST

   350

          if (symbol->transition_condition_st != NULL) {

   351

            s4o.print(s4o.indent_spaces);

   352

            print_variable_prefix();

   353

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   354

              s4o.print("__debug_");

   355

            else

   356

              s4o.print("__");

   357

            s4o.print("transition_list[");

   358

            print_transition_number();

   359

            s4o.print("] = ");

   360

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

   361

            s4o.print(";\n");

   362

          }

   363

          if (wanted_sfcgeneration == transitiontest_sg) {

   364

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

   365

            s4o.indent_right();

   366

            s4o.print(s4o.indent_spaces);

   367

            print_variable_prefix();

   368

            s4o.print("__debug_transition_list[");

   369

            print_transition_number();

   370

            s4o.print("] = ");

   371

            print_variable_prefix();

   372

            s4o.print("__transition_list[");

   373

            print_transition_number();

   374

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

   375

            s4o.indent_left();

   376

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

   377

          }

   378

          break;

   379

        default:

   380

          break;

   381

      }

   382

      return NULL;

   383

    }

   384

   385

    void *visit(action_c *symbol) {

   386

      switch (wanted_sfcgeneration) {

   387

        case actionbody_sg:

   388

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

   389

          print_variable_prefix();

   390

          s4o.print("__action_list[");

   391

          s4o.print(SFC_STEP_ACTION_PREFIX);

   392

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

   393

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

   394

          s4o.indent_right();

   395

   396

          // generate action code

   397

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

   398

   399

          s4o.indent_left();

   400

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

   401

          break;

   402

        default:

   403

          break;

   404

      }

   405

      return NULL;

   406

    }

   407

   408

    void *visit(steps_c *symbol) {

   409

      if (symbol->step_name != NULL) {

   410

        switch (wanted_sfcgeneration) {

   411

          case transitiontest_sg:

   412

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

   413

            break;

   414

          case stepset_sg:

   415

            print_set_step(symbol->step_name);

   416

            break;

   417

          case stepreset_sg:

   418

            print_reset_step(symbol->step_name);

   419

            break;

   420

          default:

   421

            break;

   422

        }

   423

      }

   424

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

   425

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

   426

      }  

   427

      return NULL;

   428

    }

   429

   430

    void *visit(step_name_list_c *symbol) {

   431

      switch (wanted_sfcgeneration) {

   432

        case transitiontest_sg:

   433

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

   434

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

   435

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

   436

              s4o.print(" && ");

   437

            }

   438

          }

   439

          break;

   440

        case stepset_sg:

   441

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

   442

            print_set_step(symbol->elements[i]);

   443

          }

   444

          break;

   445

        case stepreset_sg:

   446

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

   447

            print_reset_step(symbol->elements[i]);

   448

          }

   449

          break;

   450

        default:

   451

          break;

   452

      }

   453

      return NULL;

   454

    }

   455

   456

    void *visit(action_association_list_c* symbol) {

   457

      switch (wanted_sfcgeneration) {

   458

        case actionassociation_sg:

   459

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

   460

          break;

   461

        default:

   462

          break;

   463

      }

   464

      return NULL;

   465

    }

   466

   467

    void *visit(action_association_c *symbol) {

   468

      switch (wanted_sfcgeneration) {

   469

        case actionassociation_sg:

   470

          if (symbol->action_qualifier != NULL) {

   471

            current_action = symbol->action_name;

   472

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

   473

          }

   474

          else {

   475

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

   476

            print_step_argument(current_step, "state");

   477

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

   478

            s4o.indent_right();

   479

            s4o.print(s4o.indent_spaces);

   480

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

   481

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

   482

            s4o.indent_left();

   483

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

   484

          }

   485

          break;

   486

        default:

   487

          break;

   488

      }

   489

      return NULL;

   490

    }

   491

   492

    void *visit(action_qualifier_c *symbol) {

   493

      switch (wanted_sfcgeneration) {

   494

        case actionassociation_sg:

   495

          {

   496

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

   497

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

   498

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

   499

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

   500

              s4o.print("active");

   501

            }

   502

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

   503

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

   504

              s4o.print("activated");

   505

            }

   506

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

   507

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

   508

              print_step_argument(current_step, "elapsed_time");

   509

              s4o.print(", ");

   510

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

   511

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

   512

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

   513

              }

   514

              else {

   515

                s4o.print(") < 0");

   516

              }

   517

            }

   518

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

   519

            s4o.indent_right();

   520

            s4o.print(s4o.indent_spaces);

   521