1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

 *  This program is distributed in the hope that it will be useful,

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

 *  You should have received a copy of the GNU General Public License

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

 * This code is made available on the understanding that it will not be

    22

 * used in safety-critical situations without a full and competent review.

    23

 */

    24

    25

typedef struct

    26

{

    27

  transition_c *symbol;

    28

  int priority;

    29

  int index;

    30

} TRANSITION;

    31

    32

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

    33

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

    34

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

    35

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

    36

    37

class generate_c_sfc_elements_c: public generate_c_base_c {

    38

    39

  public:

    40

    typedef enum {

    41

      transitionlist_sg,

    42

      transitiontest_sg,

    43

      transitiontestdebug_sg,

    44

      stepset_sg,

    45

      stepreset_sg,

    46

      actionassociation_sg,

    47

      actionbody_sg

    48

    } sfcgeneration_t;

    49

    50

  private:

    51

    generate_c_il_c *generate_c_il;

    52

    generate_c_st_c *generate_c_st;

    53

    generate_c_SFC_IL_ST_c *generate_c_code;

    54

    55

    int transition_number;

    56

    std::list<TRANSITION> transition_list;

    57

    58

    symbol_c *current_step;

    59

    symbol_c *current_action;

    60

    61

    sfcgeneration_t wanted_sfcgeneration;

    62

    63

  public:

    64

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

    65

    : generate_c_base_c(s4o_ptr) {

    66

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

    67

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

    68

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

    69

      this->set_variable_prefix(variable_prefix);

    70

    }

    71

    72

    ~generate_c_sfc_elements_c(void) {

    73

      transition_list.clear();

    74

      delete generate_c_il;

    75

      delete generate_c_st;

    76

      delete generate_c_code;

    77

    }

    78

    79

    void reset_transition_number(void) {transition_number = 0;}

    80

    81

    void generate(symbol_c *symbol, sfcgeneration_t generation_type) {

    82

      wanted_sfcgeneration = generation_type;

    83

      switch (wanted_sfcgeneration) {

    84

        case transitiontest_sg:

    85

          {

    86

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

    87

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

    88

              transition_number = pt->index;

    89

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

    90

            }

    91

          }

    92

          break;

    93

        default:

    94

          symbol->accept(*this);

    95

          break;

    96

      }

    97

    }

    98

    99

    void print_step_argument(symbol_c *step_name, const char* argument, bool setter=false) {

   100

      print_variable_prefix();

   101

      if (setter) s4o.print(",");

   102

      s4o.print("__step_list[");

   103

      s4o.print(SFC_STEP_ACTION_PREFIX);

   104

      step_name->accept(*this);

   105

      s4o.print("].");

   106

      s4o.print(argument);

   107

    }

   108

   109

    void print_action_argument(symbol_c *action_name, const char* argument, bool setter=false) {

   110

      print_variable_prefix();

   111

      if (setter) s4o.print(",");

   112

      s4o.print("__action_list[");

   113

      s4o.print(SFC_STEP_ACTION_PREFIX);

   114

      action_name->accept(*this);

   115

      s4o.print("].");

   116

      s4o.print(argument);

   117

    }      

   118

   119

    void print_transition_number(void) {

   120

      s4o.print_integer(transition_number);

   121

    }

   122

   123

    void print_reset_step(symbol_c *step_name) {

   124

      s4o.print(s4o.indent_spaces);

   125

      s4o.print(SET_VAR);

   126

      s4o.print("(");

   127

      print_step_argument(step_name, "state", true);

   128

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

   129

    }

   130

   131

    void print_set_step(symbol_c *step_name) {

   132

      s4o.print(s4o.indent_spaces);

   133

      s4o.print(SET_VAR);

   134

      s4o.print("(");

   135

      print_step_argument(step_name, "state", true);

   136

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

   137

      print_step_argument(step_name, "elapsed_time");

   138

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

   139

    }

   140

   141

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

   142

/* B.1.6  Sequential function chart elements */

   143

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

   144

   145

    void *visit(initial_step_c *symbol) {

   146

      switch (wanted_sfcgeneration) {

   147

        case actionassociation_sg:

   148

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

   149

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

   150

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

   151

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

   152

            current_step = symbol->step_name;

   153

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

   154

            s4o.indent_right();

   155

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

   156

            s4o.print(GET_VAR);

   157

            s4o.print("(");

   158

            print_step_argument(current_step, "state");

   159

            s4o.print(") && !");

   160

            print_step_argument(current_step, "prev_state");

   161

            s4o.print(";\n");

   162

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

   163

            s4o.print(GET_VAR);

   164

            s4o.print("(");

   165

            print_step_argument(current_step, "state");

   166

            s4o.print(") && ");

   167

            print_step_argument(current_step, "prev_state");

   168

            s4o.print(";\n");

   169

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

   170

            s4o.print(GET_VAR);

   171

            s4o.print("(");

   172

            print_step_argument(current_step, "state");

   173

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

   174

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

   175

            s4o.indent_left();

   176

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

   177

          }

   178

          break;

   179

        default:

   180

          break;

   181

      }

   182

      return NULL;

   183

    }

   184

   185

    void *visit(step_c *symbol) {

   186

      switch (wanted_sfcgeneration) {

   187

        case actionassociation_sg:

   188

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

   189

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

   190

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

   191

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

   192

            current_step = symbol->step_name;

   193

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

   194

            s4o.indent_right();

   195

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

   196

            s4o.print(GET_VAR);

   197

            s4o.print("(");

   198

            print_step_argument(current_step, "state");

   199

            s4o.print(") && !");

   200

            print_step_argument(current_step, "prev_state");

   201

            s4o.print(";\n");

   202

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

   203

            s4o.print(GET_VAR);

   204

            s4o.print("(");

   205

            print_step_argument(current_step, "state");

   206

            s4o.print(") && ");

   207

            print_step_argument(current_step, "prev_state");

   208

            s4o.print(";\n");

   209

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

   210

            s4o.print(GET_VAR);

   211

            s4o.print("(");

   212

            print_step_argument(current_step, "state");

   213

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

   214

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

   215

            s4o.indent_left();

   216

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

   217

          }

   218

          break;

   219

        default:

   220

          break;

   221

      }

   222

      return NULL;

   223

    }

   224

   225

    void *visit(transition_c *symbol) {

   226

      switch (wanted_sfcgeneration) {

   227

        case transitionlist_sg:

   228

          {

   229

            TRANSITION *transition;

   230

            transition = new TRANSITION;

   231

            transition->symbol = symbol;

   232

            transition->index = transition_number;

   233

            if (symbol->integer != NULL) {

   234

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

   235

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

   236

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

   237

                pt++;

   238

              } 

   239

              transition_list.insert(pt, *transition);

   240

            } 

   241

            else {

   242

              transition->priority = 0;

   243

              transition_list.push_back(*transition);

   244

            }

   245

            transition_number++;

   246

          }

   247

          break;

   248

        case transitiontest_sg:

   249

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

   250

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

   251

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

   252

          s4o.indent_right();

   253

   254

          // Calculate transition value

   255

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

   256

   257

          if (symbol->integer != NULL) {

   258

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

   259

            s4o.print(GET_VAR);

   260

            s4o.print("(");

   261

            print_variable_prefix();

   262

            s4o.print("__transition_list[");

   263

            print_transition_number();

   264

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

   265

            s4o.indent_right();

   266

            wanted_sfcgeneration = stepreset_sg;

   267

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

   268

            wanted_sfcgeneration = transitiontest_sg;

   269

            s4o.indent_left();

   270

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

   271

          }

   272

          s4o.indent_left();

   273

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

   274

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

   275

          s4o.indent_right();

   276

          // Calculate transition value for debug

   277

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

   278

          s4o.indent_right();

   279

          wanted_sfcgeneration = transitiontestdebug_sg;

   280

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

   281

          wanted_sfcgeneration = transitiontest_sg;

   282

          s4o.indent_left();

   283

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

   284

          s4o.print(s4o.indent_spaces);

   285

          s4o.print(SET_VAR);

   286

          s4o.print("(");

   287

          print_variable_prefix();

   288

          s4o.print(",__transition_list[");

   289

          print_transition_number();

   290

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

   291

          s4o.indent_left();

   292

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

   293

          break;

   294

        case stepset_sg:

   295

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

   296

          s4o.print(GET_VAR);

   297

          s4o.print("(");

   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

            s4o.print(GET_VAR);

   312

            s4o.print("(");

   313

            print_variable_prefix();

   314

            s4o.print("__transition_list[");

   315

            print_transition_number();

   316

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

   317

            s4o.indent_right();

   318

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

   319

            s4o.indent_left();

   320

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

   321

          }

   322

          transition_number++;

   323

          break;

   324

        default:

   325

          break;

   326

      }

   327

      return NULL;

   328

    }

   329

   330

    void *visit(transition_condition_c *symbol) {

   331

      switch (wanted_sfcgeneration) {

   332

        case transitiontest_sg:

   333

        case transitiontestdebug_sg:

   334

          // Transition condition is in IL

   335

          if (symbol->transition_condition_il != NULL) {

   336

            generate_c_il->declare_backup_variable();

   337

            s4o.print(s4o.indent_spaces);

   338

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

   339

            s4o.print(SET_VAR);

   340

            s4o.print("(");

   341

            print_variable_prefix();

   342

            s4o.print(",");

   343

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   344

              s4o.print("__debug_");

   345

            else

   346

              s4o.print("__");

   347

            s4o.print("transition_list[");

   348

            print_transition_number();

   349

            s4o.print("],");

   350

            generate_c_il->print_backup_variable();

   351

            generate_c_il->reset_default_variable_name();

   352

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

   353

          }

   354

          // Transition condition is in ST

   355

          if (symbol->transition_condition_st != NULL) {

   356

            s4o.print(s4o.indent_spaces);

   357

            s4o.print(SET_VAR);

   358

            s4o.print("(");

   359

            print_variable_prefix();

   360

            s4o.print(",");

   361

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   362

              s4o.print("__debug_");

   363

            else

   364

              s4o.print("__");

   365

            s4o.print("transition_list[");

   366

            print_transition_number();

   367

            s4o.print("],");

   368

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

   369

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

   370

          }

   371

          if (wanted_sfcgeneration == transitiontest_sg) {

   372

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

   373

            s4o.indent_right();

   374

            s4o.print(s4o.indent_spaces);

   375

            s4o.print(SET_VAR);

   376

            s4o.print("(");

   377

            print_variable_prefix();

   378

            s4o.print(",__debug_transition_list[");

   379

            print_transition_number();

   380

            s4o.print("],");

   381

            s4o.print(GET_VAR);

   382

            s4o.print("(");

   383

            print_variable_prefix();

   384

            s4o.print("__transition_list[");

   385

            print_transition_number();

   386

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

   387

            s4o.indent_left();

   388

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

   389

          }

   390

          break;

   391

        default:

   392

          break;

   393

      }

   394

      return NULL;

   395

    }

   396

   397

    void *visit(action_c *symbol) {

   398

      switch (wanted_sfcgeneration) {

   399

        case actionbody_sg:

   400

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

   401

          print_variable_prefix();

   402

          s4o.print("__action_list[");

   403

          s4o.print(SFC_STEP_ACTION_PREFIX);

   404

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

   405

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

   406

          s4o.indent_right();

   407

   408

          // generate action code

   409

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

   410

   411

          s4o.indent_left();

   412

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

   413

          break;

   414

        default:

   415

          break;

   416

      }

   417

      return NULL;

   418

    }

   419

   420

    void *visit(steps_c *symbol) {

   421

      if (symbol->step_name != NULL) {

   422

        switch (wanted_sfcgeneration) {

   423

          case transitiontest_sg:

   424

        	s4o.print(GET_VAR);

   425

        	s4o.print("(");

   426

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

   427

            s4o.print(")");

   428

            break;

   429

          case stepset_sg:

   430

            print_set_step(symbol->step_name);

   431

            break;

   432

          case stepreset_sg:

   433

            print_reset_step(symbol->step_name);

   434

            break;

   435

          default:

   436

            break;

   437

        }

   438

      }

   439

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

   440

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

   441

      }  

   442

      return NULL;

   443

    }

   444

   445

    void *visit(step_name_list_c *symbol) {

   446

      switch (wanted_sfcgeneration) {

   447

        case transitiontest_sg:

   448

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

   449

        	s4o.print(GET_VAR);

   450

        	s4o.print("(");

   451

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

   452

            s4o.print(")");

   453

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

   454

              s4o.print(" && ");

   455

            }

   456

          }

   457

          break;

   458

        case stepset_sg:

   459

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

   460

            print_set_step(symbol->elements[i]);

   461

          }

   462

          break;

   463

        case stepreset_sg:

   464

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

   465

            print_reset_step(symbol->elements[i]);

   466

          }

   467

          break;

   468

        default:

   469

          break;

   470

      }

   471

      return NULL;

   472

    }

   473

   474

    void *visit(action_association_list_c* symbol) {

   475

      switch (wanted_sfcgeneration) {

   476

        case actionassociation_sg:

   477

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

   478

          break;

   479

        default:

   480

          break;

   481

      }

   482

      return NULL;

   483

    }

   484

   485

    void *visit(action_association_c *symbol) {

   486

      switch (wanted_sfcgeneration) {

   487

        case actionassociation_sg:

   488

          if (symbol->action_qualifier != NULL) {

   489

            current_action = symbol->action_name;

   490

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

   491

          }

   492

          else {

   493

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

   494

            s4o.print(GET_VAR);

   495

            s4o.print("(");

   496

            print_step_argument(current_step, "state");

   497

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

   498

            s4o.indent_right();

   499

            s4o.print(s4o.indent_spaces);

   500

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

   501

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

   502

            s4o.indent_left();

   503

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

   504

          }

   505

          break;

   506

        default:

   507

          break;

   508

      }

   509

      return NULL;

   510

    }