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_and_typeid_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_and_typeid_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

      step_name->accept(*this);  // in the generated C code, the 'step_name' will have been previously #define'd as equiv to '__step_list[<step_number>]", so now we simply print out the name!

   114

      s4o.print(".");

   115

      s4o.print(argument);

   116

    }

   117

   118

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

   119

      print_variable_prefix();

   120

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

   121

      s4o.print("__action_list[");

   122

      s4o.print(SFC_STEP_ACTION_PREFIX);

   123

      action_name->accept(*this);

   124

      s4o.print("].");

   125

      s4o.print(argument);

   126

    }      

   127

   128

    void print_transition_number(void) {

   129

      s4o.print(transition_number);

   130

    }

   131

   132

    void print_reset_step(symbol_c *step_name) {

   133

      s4o.print(s4o.indent_spaces);

   134

      s4o.print(SET_VAR);

   135

      s4o.print("(");

   136

      print_step_argument(step_name, "X", true);

   137

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

   138

    }

   139

   140

    void print_set_step(symbol_c *step_name) {

   141

      s4o.print(s4o.indent_spaces);

   142

      s4o.print(SET_VAR);

   143

      s4o.print("(");

   144

      print_step_argument(step_name, "X", true);

   145

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

   146

      print_step_argument(step_name, "T.value");

   147

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

   148

    }

   149

   150

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

   151

/* B.1.6  Sequential function chart elements */

   152

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

   153

   154

    void *visit(initial_step_c *symbol) {

   155

      switch (wanted_sfcgeneration) {

   156

        case actionassociation_sg:

   157

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

   158

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

   159

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

   160

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

   161

            current_step = symbol->step_name;

   162

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

   163

            s4o.indent_right();

   164

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

   165

            s4o.print(GET_VAR);

   166

            s4o.print("(");

   167

            print_step_argument(current_step, "X");

   168

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

   169

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

   170

            print_step_argument(current_step, "prev_state");

   171

            s4o.print(";\n");

   172

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

   173

            print_step_argument(current_step, "prev_state");

   174

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

   175

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

   176

            s4o.indent_left();

   177

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

   178

          }

   179

          break;

   180

        default:

   181

          break;

   182

      }

   183

      return NULL;

   184

    }

   185

   186

    void *visit(step_c *symbol) {

   187

      switch (wanted_sfcgeneration) {

   188

        case actionassociation_sg:

   189

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

   190

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

   191

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

   192

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

   193

            current_step = symbol->step_name;

   194

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

   195

            s4o.indent_right();

   196

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

   197

            s4o.print(GET_VAR);

   198

            s4o.print("(");

   199

            print_step_argument(current_step, "X");

   200

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

   201

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

   202

            print_step_argument(current_step, "prev_state");

   203

            s4o.print(";\n");

   204

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

   205

            print_step_argument(current_step, "prev_state");

   206

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

   207

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

   208

            s4o.indent_left();

   209

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

   210

          }

   211

          break;

   212

        default:

   213

          break;

   214

      }

   215

      return NULL;

   216

    }

   217

   218

    void *visit(transition_c *symbol) {

   219

      switch (wanted_sfcgeneration) {

   220

        case transitionlist_sg:

   221

          {

   222

            TRANSITION *transition;

   223

            transition = new TRANSITION;

   224

            transition->symbol = symbol;

   225

            transition->index = transition_number;

   226

            if (symbol->integer != NULL) {

   227

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

   228

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

   229

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

   230

                pt++;

   231

              } 

   232

              transition_list.insert(pt, *transition);

   233

            } 

   234

            else {

   235

              transition->priority = 0;

   236

              transition_list.push_back(*transition);

   237

            }

   238

            transition_number++;

   239

          }

   240

          break;

   241

        case transitiontest_sg:

   242

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

   243

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

   244

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

   245

          s4o.indent_right();

   246

   247

          // Calculate transition value

   248

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

   249

   250

          if (symbol->integer != NULL) {

   251

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

   252

            s4o.print(GET_VAR);

   253

            s4o.print("(");

   254

            print_variable_prefix();

   255

            s4o.print("__transition_list[");

   256

            print_transition_number();

   257

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

   258

            s4o.indent_right();

   259

            wanted_sfcgeneration = stepreset_sg;

   260

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

   261

            wanted_sfcgeneration = transitiontest_sg;

   262

            s4o.indent_left();

   263

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

   264

          }

   265

          s4o.indent_left();

   266

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

   267

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

   268

          s4o.indent_right();

   269

          // Calculate transition value for debug

   270

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

   271

          s4o.indent_right();

   272

          wanted_sfcgeneration = transitiontestdebug_sg;

   273

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

   274

          wanted_sfcgeneration = transitiontest_sg;

   275

          s4o.indent_left();

   276

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

   277

          s4o.print(s4o.indent_spaces);

   278

          s4o.print(SET_VAR);

   279

          s4o.print("(");

   280

          print_variable_prefix();

   281

          s4o.print(",__transition_list[");

   282

          print_transition_number();

   283

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

   284

          s4o.indent_left();

   285

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

   286

          break;

   287

        case stepset_sg:

   288

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

   289

          s4o.print(GET_VAR);

   290

          s4o.print("(");

   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

            s4o.print(GET_VAR);

   305

            s4o.print("(");

   306

            print_variable_prefix();

   307

            s4o.print("__transition_list[");

   308

            print_transition_number();

   309

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

   310

            s4o.indent_right();

   311

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

   312

            s4o.indent_left();

   313

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

   314

          }

   315

          transition_number++;

   316

          break;

   317

        default:

   318

          break;

   319

      }

   320

      return NULL;

   321

    }

   322

   323

    void *visit(transition_condition_c *symbol) {

   324

      switch (wanted_sfcgeneration) {

   325

        case transitiontest_sg:

   326

        case transitiontestdebug_sg:

   327

          // Transition condition is in IL

   328

          if (symbol->transition_condition_il != NULL) {

   329

            generate_c_il->declare_implicit_variable_back();

   330

            s4o.print(s4o.indent_spaces);

   331

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

   332

            s4o.print(SET_VAR);

   333

            s4o.print("(");

   334

            print_variable_prefix();

   335

            s4o.print(",");

   336

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   337

              s4o.print("__debug_");

   338

            else

   339

              s4o.print("__");

   340

            s4o.print("transition_list[");

   341

            print_transition_number();

   342

            s4o.print("],,");

   343

            generate_c_il->print_implicit_variable_back();

   344

            // generate_c_il->reset_default_variable_name(); // generate_c_il does not require his anymore

   345

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

   346

          }

   347

          // Transition condition is in ST

   348

          if (symbol->transition_condition_st != NULL) {

   349

            s4o.print(s4o.indent_spaces);

   350

            s4o.print(SET_VAR);

   351

            s4o.print("(");

   352

            print_variable_prefix();

   353

            s4o.print(",");

   354

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   355

              s4o.print("__debug_");

   356

            else

   357

              s4o.print("__");

   358

            s4o.print("transition_list[");

   359

            print_transition_number();

   360

            s4o.print("],,");

   361

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

   362

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

   363

          }

   364

          if (wanted_sfcgeneration == transitiontest_sg) {

   365

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

   366

            s4o.indent_right();

   367

            s4o.print(s4o.indent_spaces);

   368

            s4o.print(SET_VAR);

   369

            s4o.print("(");

   370

            print_variable_prefix();

   371

            s4o.print(",__debug_transition_list[");

   372

            print_transition_number();

   373

            s4o.print("],,");

   374

            s4o.print(GET_VAR);

   375

            s4o.print("(");

   376

            print_variable_prefix();

   377

            s4o.print("__transition_list[");

   378

            print_transition_number();

   379

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

   380

            s4o.indent_left();

   381

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

   382

          }

   383

          break;

   384

        default:

   385

          break;

   386

      }

   387

      return NULL;

   388

    }

   389

   390

    void *visit(action_c *symbol) {

   391

      switch (wanted_sfcgeneration) {

   392

        case actionbody_sg:

   393

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

   394

          s4o.print(GET_VAR);

   395

          s4o.print("(");

   396

          print_variable_prefix();

   397

          s4o.print("__action_list[");

   398

          s4o.print(SFC_STEP_ACTION_PREFIX);

   399

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

   400

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

   401

          s4o.indent_right();

   402

   403

          // generate action code

   404

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

   405

   406

          s4o.indent_left();

   407

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

   408

          break;

   409

        default:

   410

          break;

   411

      }

   412

      return NULL;

   413

    }

   414

   415

    void *visit(steps_c *symbol) {

   416

      if (symbol->step_name != NULL) {

   417

        switch (wanted_sfcgeneration) {

   418

          case transitiontest_sg:

   419

            s4o.print(GET_VAR);

   420

            s4o.print("(");

   421

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

   422

            s4o.print(")");

   423

            break;

   424

          case stepset_sg:

   425

            print_set_step(symbol->step_name);

   426

            break;

   427

          case stepreset_sg:

   428

            print_reset_step(symbol->step_name);

   429

            break;

   430

          default:

   431

            break;

   432

        }

   433

      }

   434

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

   435

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

   436

      }  

   437

      return NULL;

   438

    }

   439

   440

    void *visit(step_name_list_c *symbol) {

   441

      switch (wanted_sfcgeneration) {

   442

        case transitiontest_sg:

   443

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

   444

            s4o.print(GET_VAR);

   445

            s4o.print("(");

   446

            print_step_argument(symbol->get_element(i), "X");

   447

            s4o.print(")");

   448

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

   449

              s4o.print(" && ");

   450

            }

   451

          }

   452

          break;

   453

        case stepset_sg:

   454

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

   455

            print_set_step(symbol->get_element(i));

   456

          }

   457

          break;

   458

        case stepreset_sg:

   459

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

   460

            print_reset_step(symbol->get_element(i));

   461

          }

   462

          break;

   463

        default:

   464

          break;

   465

      }

   466

      return NULL;

   467

    }

   468

   469

    void *visit(action_association_list_c* symbol) {

   470

      switch (wanted_sfcgeneration) {

   471

        case actionassociation_sg:

   472

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

   473

          break;

   474

        default:

   475

          break;

   476

      }

   477

      return NULL;

   478

    }

   479

   480

    void *visit(action_association_c *symbol) {

   481

      switch (wanted_sfcgeneration) {

   482

        case actionassociation_sg:

   483

          if (symbol->action_qualifier != NULL) {

   484

            current_action = symbol->action_name;

   485

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

   486

          }

   487

          else {

   488

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

   489

            s4o.print(GET_VAR);

   490

            s4o.print("(");

   491

            print_step_argument(current_step, "X");

   492

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

   493

            s4o.indent_right();

   494

            s4o.print(s4o.indent_spaces);

   495

            s4o.print(SET_VAR);

   496

            s4o.print("(");

   497

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

   498

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

   499

            s4o.indent_left();

   500

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

   501

          }

   502

          break;

   503

        default:

   504

          break;

   505

      }

   506

      return NULL;

   507

    }

   508