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

    search_var_instance_decl_c *search_var_instance_decl;

    55

    56

    int transition_number;

    57

    std::list<TRANSITION> transition_list;

    58

    59

    symbol_c *current_step;

    60

    symbol_c *current_action;

    61

    62

    sfcgeneration_t wanted_sfcgeneration;

    63

    64

  public:

    65

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

    66

    : generate_c_base_c(s4o_ptr) {

    67

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

    68

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

    69

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

    70

      search_var_instance_decl = new search_var_instance_decl_c(scope);

    71

      this->set_variable_prefix(variable_prefix);

    72

    }

    73

    74

    ~generate_c_sfc_elements_c(void) {

    75

      transition_list.clear();

    76

      delete generate_c_il;

    77

      delete generate_c_st;

    78

      delete generate_c_code;

    79

      delete search_var_instance_decl;

    80

    }

    81

    82

    83

	bool is_variable(symbol_c *symbol) {

    84

	  /* we try to find the variable instance declaration, to determine if symbol is variable... */

    85

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

    86

    87

	  return var_decl != NULL;

    88

	}

    89

    90

    void reset_transition_number(void) {transition_number = 0;}

    91

    92

    void generate(symbol_c *symbol, sfcgeneration_t generation_type) {

    93

      wanted_sfcgeneration = generation_type;

    94

      switch (wanted_sfcgeneration) {

    95

        case transitiontest_sg:

    96

          {

    97

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

    98

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

    99

              transition_number = pt->index;

   100

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

   101

            }

   102

          }

   103

          break;

   104

        default:

   105

          symbol->accept(*this);

   106

          break;

   107

      }

   108

    }

   109

   110

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

   111

      print_variable_prefix();

   112

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

   113

      s4o.print("__step_list[");

   114

      s4o.print(SFC_STEP_ACTION_PREFIX);

   115

      step_name->accept(*this);

   116

      s4o.print("].");

   117

      s4o.print(argument);

   118

    }

   119

   120

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

   121

      print_variable_prefix();

   122

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

   123

      s4o.print("__action_list[");

   124

      s4o.print(SFC_STEP_ACTION_PREFIX);

   125

      action_name->accept(*this);

   126

      s4o.print("].");

   127

      s4o.print(argument);

   128

    }      

   129

   130

    void print_transition_number(void) {

   131

      s4o.print(transition_number);

   132

    }

   133

   134

    void print_reset_step(symbol_c *step_name) {

   135

      s4o.print(s4o.indent_spaces);

   136

      s4o.print(SET_VAR);

   137

      s4o.print("(");

   138

      print_step_argument(step_name, "state", true);

   139

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

   140

    }

   141

   142

    void print_set_step(symbol_c *step_name) {

   143

      s4o.print(s4o.indent_spaces);

   144

      s4o.print(SET_VAR);

   145

      s4o.print("(");

   146

      print_step_argument(step_name, "state", true);

   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

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

   153

/* B.1.6  Sequential function chart elements */

   154

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

   155

   156

    void *visit(initial_step_c *symbol) {

   157

      switch (wanted_sfcgeneration) {

   158

        case actionassociation_sg:

   159

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

   160

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

   161

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

   162

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

   163

            current_step = symbol->step_name;

   164

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

   165

            s4o.indent_right();

   166

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

   167

            s4o.print(GET_VAR);

   168

            s4o.print("(");

   169

            print_step_argument(current_step, "state");

   170

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

   171

            print_step_argument(current_step, "prev_state");

   172

            s4o.print(";\n");

   173

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

   174

            s4o.print(GET_VAR);

   175

            s4o.print("(");

   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 active = ");

   181

            s4o.print(GET_VAR);

   182

            s4o.print("(");

   183

            print_step_argument(current_step, "state");

   184

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

   185

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

   186

            s4o.indent_left();

   187

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

   188

          }

   189

          break;

   190

        default:

   191

          break;

   192

      }

   193

      return NULL;

   194

    }

   195

   196

    void *visit(step_c *symbol) {

   197

      switch (wanted_sfcgeneration) {

   198

        case actionassociation_sg:

   199

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

   200

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

   201

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

   202

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

   203

            current_step = symbol->step_name;

   204

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

   205

            s4o.indent_right();

   206

            s4o.print(s4o.indent_spaces + "char activated, desactivated, active;\n");

   207

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

   208

            s4o.print(GET_VAR);

   209

            s4o.print("(");

   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 + "desactivated = !");

   215

            s4o.print(GET_VAR);

   216

            s4o.print("(");

   217

            print_step_argument(current_step, "state");

   218

            s4o.print(") && ");

   219

            print_step_argument(current_step, "prev_state");

   220

            s4o.print(";\n");

   221

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

   222

            s4o.print(GET_VAR);

   223

            s4o.print("(");

   224

            print_step_argument(current_step, "state");

   225

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

   226

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

   227

            s4o.indent_left();

   228

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

   229

          }

   230

          break;

   231

        default:

   232

          break;

   233

      }

   234

      return NULL;

   235

    }

   236

   237

    void *visit(transition_c *symbol) {

   238

      switch (wanted_sfcgeneration) {

   239

        case transitionlist_sg:

   240

          {

   241

            TRANSITION *transition;

   242

            transition = new TRANSITION;

   243

            transition->symbol = symbol;

   244

            transition->index = transition_number;

   245

            if (symbol->integer != NULL) {

   246

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

   247

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

   248

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

   249

                pt++;

   250

              } 

   251

              transition_list.insert(pt, *transition);

   252

            } 

   253

            else {

   254

              transition->priority = 0;

   255

              transition_list.push_back(*transition);

   256

            }

   257

            transition_number++;

   258

          }

   259

          break;

   260

        case transitiontest_sg:

   261

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

   262

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

   263

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

   264

          s4o.indent_right();

   265

   266

          // Calculate transition value

   267

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

   268

   269

          if (symbol->integer != NULL) {

   270

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

   271

            s4o.print(GET_VAR);

   272

            s4o.print("(");

   273

            print_variable_prefix();

   274

            s4o.print("__transition_list[");

   275

            print_transition_number();

   276

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

   277

            s4o.indent_right();

   278

            wanted_sfcgeneration = stepreset_sg;

   279

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

   280

            wanted_sfcgeneration = transitiontest_sg;

   281

            s4o.indent_left();

   282

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

   283

          }

   284

          s4o.indent_left();

   285

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

   286

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

   287

          s4o.indent_right();

   288

          // Calculate transition value for debug

   289

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

   290

          s4o.indent_right();

   291

          wanted_sfcgeneration = transitiontestdebug_sg;

   292

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

   293

          wanted_sfcgeneration = transitiontest_sg;

   294

          s4o.indent_left();

   295

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

   296

          s4o.print(s4o.indent_spaces);

   297

          s4o.print(SET_VAR);

   298

          s4o.print("(");

   299

          print_variable_prefix();

   300

          s4o.print(",__transition_list[");

   301

          print_transition_number();

   302

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

   303

          s4o.indent_left();

   304

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

   305

          break;

   306

        case stepset_sg:

   307

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

   308

          s4o.print(GET_VAR);

   309

          s4o.print("(");

   310

          print_variable_prefix();

   311

          s4o.print("__transition_list[");

   312

          print_transition_number();

   313

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

   314

          s4o.indent_right();

   315

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

   316

          s4o.indent_left();

   317

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

   318

          transition_number++;

   319

          break;

   320

        case stepreset_sg:

   321

          if (symbol->integer == NULL) {

   322

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

   323

            s4o.print(GET_VAR);

   324

            s4o.print("(");

   325

            print_variable_prefix();

   326

            s4o.print("__transition_list[");

   327

            print_transition_number();

   328

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

   329

            s4o.indent_right();

   330

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

   331

            s4o.indent_left();

   332

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

   333

          }

   334

          transition_number++;

   335

          break;

   336

        default:

   337

          break;

   338

      }

   339

      return NULL;

   340

    }

   341

   342

    void *visit(transition_condition_c *symbol) {

   343

      switch (wanted_sfcgeneration) {

   344

        case transitiontest_sg:

   345

        case transitiontestdebug_sg:

   346

          // Transition condition is in IL

   347

          if (symbol->transition_condition_il != NULL) {

   348

            generate_c_il->declare_backup_variable();

   349

            s4o.print(s4o.indent_spaces);

   350

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

   351

            s4o.print(SET_VAR);

   352

            s4o.print("(");

   353

            print_variable_prefix();

   354

            s4o.print(",");

   355

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   356

              s4o.print("__debug_");

   357

            else

   358

              s4o.print("__");

   359

            s4o.print("transition_list[");

   360

            print_transition_number();

   361

            s4o.print("],");

   362

            generate_c_il->print_backup_variable();

   363

            generate_c_il->reset_default_variable_name();

   364

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

   365

          }

   366

          // Transition condition is in ST

   367

          if (symbol->transition_condition_st != NULL) {

   368

            s4o.print(s4o.indent_spaces);

   369

            s4o.print(SET_VAR);

   370

            s4o.print("(");

   371

            print_variable_prefix();

   372

            s4o.print(",");

   373

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   374

              s4o.print("__debug_");

   375

            else

   376

              s4o.print("__");

   377

            s4o.print("transition_list[");

   378

            print_transition_number();

   379

            s4o.print("],");

   380

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

   381

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

   382

          }

   383

          if (wanted_sfcgeneration == transitiontest_sg) {

   384

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

   385

            s4o.indent_right();

   386

            s4o.print(s4o.indent_spaces);

   387

            s4o.print(SET_VAR);

   388

            s4o.print("(");

   389

            print_variable_prefix();

   390

            s4o.print(",__debug_transition_list[");

   391

            print_transition_number();

   392

            s4o.print("],");

   393

            s4o.print(GET_VAR);

   394

            s4o.print("(");

   395

            print_variable_prefix();

   396

            s4o.print("__transition_list[");

   397

            print_transition_number();

   398

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

   399

            s4o.indent_left();

   400

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

   401

          }

   402

          break;

   403

        default:

   404

          break;

   405

      }

   406

      return NULL;

   407

    }

   408

   409

    void *visit(action_c *symbol) {

   410

      switch (wanted_sfcgeneration) {

   411

        case actionbody_sg:

   412

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

   413

          s4o.print(GET_VAR);

   414

          s4o.print("(");

   415

          print_variable_prefix();

   416

          s4o.print("__action_list[");

   417

          s4o.print(SFC_STEP_ACTION_PREFIX);

   418

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

   419

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

   420

          s4o.indent_right();

   421

   422

          // generate action code

   423

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

   424

   425

          s4o.indent_left();

   426

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

   427

          break;

   428

        default:

   429

          break;

   430

      }

   431

      return NULL;

   432

    }

   433

   434

    void *visit(steps_c *symbol) {

   435

      if (symbol->step_name != NULL) {

   436

        switch (wanted_sfcgeneration) {

   437

          case transitiontest_sg:

   438

            s4o.print(GET_VAR);

   439

            s4o.print("(");

   440

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

   441

            s4o.print(")");

   442

            break;

   443

          case stepset_sg:

   444

            print_set_step(symbol->step_name);

   445

            break;

   446

          case stepreset_sg:

   447

            print_reset_step(symbol->step_name);

   448

            break;

   449

          default:

   450

            break;

   451

        }

   452

      }

   453

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

   454

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

   455

      }  

   456

      return NULL;

   457

    }

   458

   459

    void *visit(step_name_list_c *symbol) {

   460

      switch (wanted_sfcgeneration) {

   461

        case transitiontest_sg:

   462

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

   463

            s4o.print(GET_VAR);

   464

            s4o.print("(");

   465

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

   466

            s4o.print(")");

   467

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

   468

              s4o.print(" && ");

   469

            }

   470

          }

   471

          break;

   472

        case stepset_sg:

   473

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

   474

            print_set_step(symbol->elements[i]);

   475

          }

   476

          break;

   477

        case stepreset_sg:

   478

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

   479

            print_reset_step(symbol->elements[i]);

   480

          }

   481

          break;

   482

        default:

   483

          break;

   484

      }

   485

      return NULL;

   486

    }

   487

   488

    void *visit(action_association_list_c* symbol) {

   489

      switch (wanted_sfcgeneration) {

   490

        case actionassociation_sg:

   491

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

   492

          break;

   493

        default:

   494

          break;

   495

      }

   496

      return NULL;

   497

    }

   498

   499

    void *visit(action_association_c *symbol) {

   500

      switch (wanted_sfcgeneration) {

   501

        case actionassociation_sg:

   502

          if (symbol->action_qualifier != NULL) {

   503

            current_action = symbol->action_name;

   504

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

   505

          }

   506

          else {

   507

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

   508

            s4o.print(GET_VAR);