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

    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)

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

   165

            s4o.print(GET_VAR);

   166

            s4o.print("(");

   167

            print_step_argument(current_step, "X");

   168

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

   169

            print_step_argument(current_step, "prev_state");

   170

            s4o.print(";\n");

   171

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

   172

            s4o.print(GET_VAR);

   173

            s4o.print("(");

   174

            print_step_argument(current_step, "X");

   175

            s4o.print(") && ");

   176

            print_step_argument(current_step, "prev_state");

   177

            s4o.print(";\n");

   178

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

   179

            s4o.print(GET_VAR);

   180

            s4o.print("(");

   181

            print_step_argument(current_step, "X");

   182

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

   183

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

   184

            s4o.indent_left();

   185

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

   186

          }

   187

          break;

   188

        default:

   189

          break;

   190

      }

   191

      return NULL;

   192

    }

   193

   194

    void *visit(step_c *symbol) {

   195

      switch (wanted_sfcgeneration) {

   196

        case actionassociation_sg:

   197

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

   198

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

   199

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

   200

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

   201

            current_step = symbol->step_name;

   202

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

   203

            s4o.indent_right();

   204

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

   205

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

   206

            s4o.print(GET_VAR);

   207

            s4o.print("(");

   208

            print_step_argument(current_step, "X");

   209

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

   210

            print_step_argument(current_step, "prev_state");

   211

            s4o.print(";\n");

   212

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

   213

            s4o.print(GET_VAR);

   214

            s4o.print("(");

   215

            print_step_argument(current_step, "X");

   216

            s4o.print(") && ");

   217

            print_step_argument(current_step, "prev_state");

   218

            s4o.print(";\n");

   219

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

   220

            s4o.print(GET_VAR);

   221

            s4o.print("(");

   222

            print_step_argument(current_step, "X");

   223

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

   224

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

   225

            s4o.indent_left();

   226

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

   227

          }

   228

          break;

   229

        default:

   230

          break;

   231

      }

   232

      return NULL;

   233

    }

   234

   235

    void *visit(transition_c *symbol) {

   236

      switch (wanted_sfcgeneration) {

   237

        case transitionlist_sg:

   238

          {

   239

            TRANSITION *transition;

   240

            transition = new TRANSITION;

   241

            transition->symbol = symbol;

   242

            transition->index = transition_number;

   243

            if (symbol->integer != NULL) {

   244

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

   245

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

   246

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

   247

                pt++;

   248

              } 

   249

              transition_list.insert(pt, *transition);

   250

            } 

   251

            else {

   252

              transition->priority = 0;

   253

              transition_list.push_back(*transition);

   254

            }

   255

            transition_number++;

   256

          }

   257

          break;

   258

        case transitiontest_sg:

   259

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

   260

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

   261

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

   262

          s4o.indent_right();

   263

   264

          // Calculate transition value

   265

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

   266

   267

          if (symbol->integer != NULL) {

   268

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

   269

            s4o.print(GET_VAR);

   270

            s4o.print("(");

   271

            print_variable_prefix();

   272

            s4o.print("__transition_list[");

   273

            print_transition_number();

   274

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

   275

            s4o.indent_right();

   276

            wanted_sfcgeneration = stepreset_sg;

   277

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

   278

            wanted_sfcgeneration = transitiontest_sg;

   279

            s4o.indent_left();

   280

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

   281

          }

   282

          s4o.indent_left();

   283

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

   284

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

   285

          s4o.indent_right();

   286

          // Calculate transition value for debug

   287

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

   288

          s4o.indent_right();

   289

          wanted_sfcgeneration = transitiontestdebug_sg;

   290

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

   291

          wanted_sfcgeneration = transitiontest_sg;

   292

          s4o.indent_left();

   293

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

   294

          s4o.print(s4o.indent_spaces);

   295

          s4o.print(SET_VAR);

   296

          s4o.print("(");

   297

          print_variable_prefix();

   298

          s4o.print(",__transition_list[");

   299

          print_transition_number();

   300

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

   301

          s4o.indent_left();

   302

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

   303

          break;

   304

        case stepset_sg:

   305

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

   306

          s4o.print(GET_VAR);

   307

          s4o.print("(");

   308

          print_variable_prefix();

   309

          s4o.print("__transition_list[");

   310

          print_transition_number();

   311

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

   312

          s4o.indent_right();

   313

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

   314

          s4o.indent_left();

   315

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

   316

          transition_number++;

   317

          break;

   318

        case stepreset_sg:

   319

          if (symbol->integer == NULL) {

   320

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

   321

            s4o.print(GET_VAR);

   322

            s4o.print("(");

   323

            print_variable_prefix();

   324

            s4o.print("__transition_list[");

   325

            print_transition_number();

   326

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

   327

            s4o.indent_right();

   328

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

   329

            s4o.indent_left();

   330

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

   331

          }

   332

          transition_number++;

   333

          break;

   334

        default:

   335

          break;

   336

      }

   337

      return NULL;

   338

    }

   339

   340

    void *visit(transition_condition_c *symbol) {

   341

      switch (wanted_sfcgeneration) {

   342

        case transitiontest_sg:

   343

        case transitiontestdebug_sg:

   344

          // Transition condition is in IL

   345

          if (symbol->transition_condition_il != NULL) {

   346

            generate_c_il->declare_implicit_variable_back();

   347

            s4o.print(s4o.indent_spaces);

   348

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

   349

            s4o.print(SET_VAR);

   350

            s4o.print("(");

   351

            print_variable_prefix();

   352

            s4o.print(",");

   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

            generate_c_il->print_implicit_variable_back();

   361

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

   362

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

   363

          }

   364

          // Transition condition is in ST

   365

          if (symbol->transition_condition_st != NULL) {

   366

            s4o.print(s4o.indent_spaces);

   367

            s4o.print(SET_VAR);

   368

            s4o.print("(");

   369

            print_variable_prefix();

   370

            s4o.print(",");

   371

            if (wanted_sfcgeneration == transitiontestdebug_sg)

   372

              s4o.print("__debug_");

   373

            else

   374

              s4o.print("__");

   375

            s4o.print("transition_list[");

   376

            print_transition_number();

   377

            s4o.print("],,");

   378

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

   379

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

   380

          }

   381

          if (wanted_sfcgeneration == transitiontest_sg) {

   382

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

   383

            s4o.indent_right();

   384

            s4o.print(s4o.indent_spaces);

   385

            s4o.print(SET_VAR);

   386

            s4o.print("(");

   387

            print_variable_prefix();

   388

            s4o.print(",__debug_transition_list[");

   389

            print_transition_number();

   390

            s4o.print("],,");

   391

            s4o.print(GET_VAR);

   392

            s4o.print("(");

   393

            print_variable_prefix();

   394

            s4o.print("__transition_list[");

   395

            print_transition_number();

   396

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

   397

            s4o.indent_left();

   398

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

   399

          }

   400

          break;

   401

        default:

   402

          break;

   403

      }

   404

      return NULL;

   405

    }

   406

   407

    void *visit(action_c *symbol) {

   408

      switch (wanted_sfcgeneration) {

   409

        case actionbody_sg:

   410

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

   411

          s4o.print(GET_VAR);

   412

          s4o.print("(");

   413

          print_variable_prefix();

   414

          s4o.print("__action_list[");

   415

          s4o.print(SFC_STEP_ACTION_PREFIX);

   416

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

   417

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

   418

          s4o.indent_right();

   419

   420

          // generate action code

   421

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

   422

   423

          s4o.indent_left();

   424

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

   425

          break;

   426

        default:

   427

          break;

   428

      }

   429

      return NULL;

   430

    }

   431

   432

    void *visit(steps_c *symbol) {

   433

      if (symbol->step_name != NULL) {

   434

        switch (wanted_sfcgeneration) {

   435

          case transitiontest_sg:

   436

            s4o.print(GET_VAR);

   437

            s4o.print("(");

   438

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

   439

            s4o.print(")");

   440

            break;

   441

          case stepset_sg:

   442

            print_set_step(symbol->step_name);

   443

            break;

   444

          case stepreset_sg:

   445

            print_reset_step(symbol->step_name);

   446

            break;

   447

          default:

   448

            break;

   449

        }

   450

      }

   451

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

   452

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

   453

      }  

   454

      return NULL;

   455

    }

   456

   457

    void *visit(step_name_list_c *symbol) {

   458

      switch (wanted_sfcgeneration) {

   459

        case transitiontest_sg:

   460

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

   461

            s4o.print(GET_VAR);

   462

            s4o.print("(");

   463

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

   464

            s4o.print(")");

   465

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

   466

              s4o.print(" && ");

   467

            }

   468

          }

   469

          break;

   470

        case stepset_sg:

   471

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

   472

            print_set_step(symbol->elements[i]);

   473

          }

   474

          break;

   475

        case stepreset_sg:

   476

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

   477

            print_reset_step(symbol->elements[i]);

   478

          }

   479

          break;

   480

        default:

   481

          break;

   482

      }

   483

      return NULL;

   484

    }

   485

   486

    void *visit(action_association_list_c* symbol) {

   487

      switch (wanted_sfcgeneration) {

   488

        case actionassociation_sg:

   489

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

   490

          break;

   491

        default:

   492

          break;

   493

      }

   494

      return NULL;

   495

    }

   496

   497

    void *visit(action_association_c *symbol) {

   498

      switch (wanted_sfcgeneration) {

   499

        case actionassociation_sg:

   500

          if (symbol->action_qualifier != NULL) {

   501

            current_action = symbol->action_name;

   502

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

   503

          }

   504

          else {

   505

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

   506

            s4o.print(GET_VAR);

   507

            s4o.print("(");