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

    35

    36

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

    37

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

    38

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

    39

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

    40

    41

class transition_element {

    42

    43

  private:

    44

    transition_c *transition;

    45

    char priority;

    46

    char index;

    47

    transition_element *prev;

    48

    transition_element *next;

    49

    50

  public:

    51

    transition_element(transition_c *tr, char pr, char idx) {

    54

      transition = tr;

    55

      priority = pr;

    56

      index = idx;

    57

    }

    58

    59

    void set_prev(transition_element *tr) {prev = tr;}

    60

    void set_next(transition_element *tr) {next = tr;}

    61

    transition_element *get_prev(void) {return prev;}

    62

    transition_element *get_next(void) {return next;}

    63

    transition_c *get_transition(void) {return transition;}

    64

    char get_priority(void) {return priority;}

    65

    char get_index(void) {return index;}

    66

};

    67

    68

    69

    70

    71

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

    72

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

    73

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

    74

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

    75

    76

class generate_cc_sfc_transitionresetsteps_c: public generate_cc_base_c {

    77

    78

  private:

    79

    char transition_number;

    80

    81

  public:

    82

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

    83

    : generate_cc_base_c(s4o_ptr) {

    84

      this->set_variable_prefix(variable_prefix);

    85

    }

    86

    87

    void set_transition_number(char number) {transition_number = number;}

    88

    void reset_transition_number(void) {transition_number = 0;}

    89

    void print_transition_number(void) {

    90

      char str[10];

    91

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

    92

      s4o.print(str);

    93

    }

    94

    95

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

    96

      print_variable_prefix();

    97

      s4o.print("step_list[");

    98

      s4o.print(SFC_STEP_ACTION_PREFIX);

    99

      step_name->accept(*this);

   100

      s4o.print("].");

   101

      s4o.print(argument);

   102

    }

   103

   104

    void print_reset_step(symbol_c *step_name) {

   105

      s4o.print(s4o.indent_spaces);

   106

      print_step_argument(step_name, "state");

   107

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

   108

    }

   109

   110

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

   111

/* B.1.6  Sequential function chart elements */

   112

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

   113

   114

    void *visit(initial_step_c *symbol) {return NULL;}

   115

   116

    void *visit(step_c *symbol) {return NULL;}

   117

   118

    void *visit(transition_c *symbol) {

   119

      if (symbol->integer == NULL) {

   120

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

   121

        print_variable_prefix();

   122

        s4o.print("transition_list[");

   123

        print_transition_number();

   124

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

   125

        s4o.indent_right();

   126

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

   127

        s4o.indent_left();

   128

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

   129

      }

   130

      transition_number++;

   131

      return NULL;

   132

    }

   133

   134

    void *visit(steps_c *symbol) {

   135

      if (symbol->step_name != NULL) {

   136

        print_reset_step(symbol->step_name);

   137

      }

   138

      if (symbol->step_name_list != NULL) {

   139

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

   140

      }

   141

      return NULL;

   142

    }

   143

   144

    void *visit(step_name_list_c *symbol) {

   145

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

   146

        print_reset_step(symbol->elements[i]);

   147

      }

   148

      return NULL;

   149

    }

   150

   151

    void *visit(action_c *symbol) {return NULL;}

   152

   153

}; /* generate_cc_sfc_transitionresetsteps_c */

   154

   155

   156

   157

   158

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

   159

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

   160

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

   161

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

   162

   163

class generate_cc_sfc_transitionsetsteps_c: public generate_cc_base_c {

   164

   165

  private:

   166

    char transition_number;

   167

   168

  public:

   169

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

   170

    : generate_cc_base_c(s4o_ptr) {

   171

      this->set_variable_prefix(variable_prefix);

   172

    }

   173

   174

    void reset_transition_number(void) {transition_number = 0;}

   175

    void print_transition_number(void) {

   176

      char str[10];

   177

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

   178

      s4o.print(str);

   179

    }

   180

   181

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

   182

      print_variable_prefix();

   183

      s4o.print("step_list[");

   184

      s4o.print(SFC_STEP_ACTION_PREFIX);

   185

      step_name->accept(*this);

   186

      s4o.print("].");

   187

      s4o.print(argument);

   188

    }

   189

   190

    void print_set_step(symbol_c *step_name) {

   191

      s4o.print(s4o.indent_spaces);

   192

      print_step_argument(step_name, "state");

   193

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

   194

      print_step_argument(step_name, "elapsed_time");

   195

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

   196

    }

   197

   198

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

   199

/* B.1.6  Sequential function chart elements */

   200

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

   201

   202

    void *visit(initial_step_c *symbol) {return NULL;}

   203

   204

    void *visit(step_c *symbol) {return NULL;}

   205

   206

    void *visit(transition_c *symbol) {

   207

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

   208

      print_variable_prefix();

   209

      s4o.print("transition_list[");

   210

      print_transition_number();

   211

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

   212

      s4o.indent_right();

   213

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

   214

      s4o.indent_left();

   215

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

   216

      transition_number++;

   217

      return NULL;

   218

    }

   219

   220

    void *visit(steps_c *symbol) {

   221

      if (symbol->step_name != NULL) {

   222

        print_set_step(symbol->step_name);

   223

      }

   224

      if (symbol->step_name_list != NULL) {

   225

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

   226

      }

   227

      return NULL;

   228

    }

   229

   230

    void *visit(step_name_list_c *symbol) {

   231

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

   232

        print_set_step(symbol->elements[i]);

   233

      }

   234

      return NULL;

   235

    }

   236

   237

    void *visit(action_c *symbol) {return NULL;}

   238

   239

}; /* generate_cc_sfc_transitionsetsteps_c */

   240

   241

   242

   243

   244

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

   245

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

   246

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

   247

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

   248

   249

class generate_cc_sfc_transitiontest_c: public generate_cc_base_c {

   250

   251

  private:

   252

    char transition_number;

   253

   254

  private:

   255

    generate_cc_il_c *generate_cc_il;

   256

    generate_cc_st_c *generate_cc_st;

   257

    generate_cc_sfc_transitionresetsteps_c *generate_cc_sfc_transitionresetsteps;

   258

   259

  public:

   260

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

   261

    : generate_cc_base_c(s4o_ptr) {

   262

      generate_cc_il = new generate_cc_il_c(s4o_ptr, scope, variable_prefix);

   263

      generate_cc_st = new generate_cc_st_c(s4o_ptr, scope, variable_prefix);

   264

      generate_cc_sfc_transitionresetsteps = new generate_cc_sfc_transitionresetsteps_c(s4o_ptr, scope, variable_prefix);

   265

      this->set_variable_prefix(variable_prefix);

   266

    }

   267

   268

    ~generate_cc_sfc_transitiontest_c(void) {

   269

      delete generate_cc_il;

   270

      delete generate_cc_st;

   271

      delete generate_cc_sfc_transitionresetsteps;

   272

    }

   273

   274

    void set_transition_number(char number) {transition_number = number;}

   275

    void print_transition_number(void) {

   276

      char str[10];

   277

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

   278

      s4o.print(str);

   279

    }

   280

   281

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

   282

      print_variable_prefix();

   283

      s4o.print("step_list[");

   284

      s4o.print(SFC_STEP_ACTION_PREFIX);

   285

      step_name->accept(*this);

   286

      s4o.print("].");

   287

      s4o.print(argument);

   288

    }

   289

   290

    void print_reset_step(symbol_c *step_name) {

   291

      s4o.print(s4o.indent_spaces);

   292

      print_step_argument(step_name, "state");

   293

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

   294

    }

   295

   296

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

   297

/* B.1.6  Sequential function chart elements */

   298

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

   299

   300

    void *visit(transition_c *symbol) {

   301

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

   302

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

   303

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

   304

      s4o.indent_right();

   305

   306

      // Calculate transition value

   307

      if (symbol->transition_condition_il != NULL) {

   308

        generate_cc_il->declare_backup_variable();

   309

        s4o.print(s4o.indent_spaces);

   310

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

   311

        print_variable_prefix();

   312

        s4o.print("transition_list[");

   313

        print_transition_number();

   314

        s4o.print("] = ");

   315

        generate_cc_il->print_backup_variable();

   316

        s4o.print(";\n");

   317

      }

   318

      if (symbol->transition_condition_st != NULL) {

   319

        s4o.print(s4o.indent_spaces);

   320

        print_variable_prefix();

   321

        s4o.print("transition_list[");

   322

        print_transition_number();

   323

        s4o.print("] = ");

   324

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

   325

        s4o.print(";\n");

   326

      }

   327

      if (symbol->integer != NULL) {

   328

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

   329

        print_variable_prefix();

   330

        s4o.print("transition_list[");

   331

        print_transition_number();

   332

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

   333

        s4o.indent_right();

   334

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

   335

        s4o.indent_left();

   336

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

   337

      }

   338

      s4o.indent_left();

   339

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

   340

      s4o.indent_right();

   341

      s4o.print(s4o.indent_spaces);

   342

      print_variable_prefix();

   343

      s4o.print("transition_list[");

   344

      print_transition_number();

   345

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

   346

      s4o.indent_left();

   347

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

   348

   349

      transition_number++;

   350

      return NULL;

   351

    }

   352

   353

    void *visit(steps_c *symbol) {

   354

      if (symbol->step_name != NULL) {

   355

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

   356

      }

   357

      if (symbol->step_name_list != NULL) {

   358

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

   359

      }

   360

      return NULL;

   361

    }

   362

   363

    void *visit(step_name_list_c *symbol) {

   364

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

   365

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

   366

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

   367

          s4o.print(" && ");

   368

        }

   369

      }

   370

      return NULL;

   371

    }

   372

   373

}; /* generate_cc_sfc_transitiontest_c */

   374

   375

   376

   377

   378

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

   379

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

   380

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

   381

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

   382

   383

class generate_cc_sfc_transitionsort_c: public iterator_visitor_c {

   384

   385

  private:

   386

    char transition_number;

   387

    transition_element *first_transition;

   388

    transition_element *last_transition;

   389

   390

  private:

   391

    generate_cc_sfc_transitiontest_c *generate_cc_sfc_transitiontest;

   392

   393

  public:

   394

    generate_cc_sfc_transitionsort_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) {

   395

      generate_cc_sfc_transitiontest = new generate_cc_sfc_transitiontest_c(s4o_ptr, scope, variable_prefix);

   396

      first_transition = NULL;

   397

      last_transition = NULL;

   398

    }

   399

   400

    ~generate_cc_sfc_transitionsort_c(void) {

   401

      delete generate_cc_sfc_transitiontest;

   402

    }

   403

   404

    void append_transition(transition_c *transition, char priority, char index) {

   405

      transition_element *new_transition = new transition_element(transition, priority, index);

   406

      new_transition->set_prev(last_transition);

   407

      if (last_transition != NULL) {

   408

        last_transition->set_next(new_transition);

   409

      }

   410

      else {

   411

        first_transition = new_transition;

   412

      }

   413

      last_transition = new_transition;

   414

      transition_number++;

   415

    }

   416

   417

    void sort_transitions(void) {

   418

      int i, j;

   419

      transition_element *current_transition;

   420

      transition_element *next_transition;

   421

      for (i = transition_number; i > 1; i--) {

   422

        current_transition = first_transition;

   423

        for (j = 0; j < i - 1; j++) {

   424

          next_transition = current_transition->get_next();

   425

          if (current_transition->get_priority() > next_transition->get_priority()) {

   426

            if (current_transition->get_prev() != NULL) {

   427

              current_transition->get_prev()->set_next(next_transition);

   428

            }

   429

            else {

   430

              first_transition = next_transition;

   431

            }

   432

            if (next_transition->get_next() != NULL) {

   433

              next_transition->get_next()->set_prev(current_transition);

   434

            }

   435

            else {

   436

              last_transition = current_transition;

   437

            }

   438

            current_transition->set_next(next_transition->get_next());

   439

            next_transition->set_prev(current_transition->get_prev());

   440

            current_transition->set_prev(next_transition);

   441

            next_transition->set_next(current_transition);

   442

          }

   443

          else {

   444

            current_transition = next_transition;

   445

          }

   446

        }

   447

      }

   448

    }

   449

   450

    void reset_transition_number(void) {transition_number = 0;}

   451

   452

    void generate(symbol_c *symbol) {

   453

      symbol->accept(*this);

   454

      sort_transitions();

   455

      transition_element *next_transition = first_transition;

   456

      while (next_transition != NULL) {

   457

        generate_cc_sfc_transitiontest->set_transition_number(next_transition->get_index());

   458

        next_transition->get_transition()->accept(*generate_cc_sfc_transitiontest);

   459

        next_transition = next_transition->get_next();

   460

      }

   461

    }

   462

   463

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

   464

/* B.1.6  Sequential function chart elements */

   465

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

   466

   467

    void *visit(initial_step_c *symbol) {return NULL;}

   468

   469

    void *visit(step_c *symbol) {return NULL;}

   470

   471

    void *visit(transition_c *symbol) {

   472

      if (symbol->integer != NULL) {

   473

        append_transition(symbol, atoi(((token_c *)symbol->integer)->value), transition_number);

   474

      }

   475

      else {

   476

        append_transition(symbol, 0, transition_number);

   477

      }

   478

      return NULL;

   479

    }

   480

   481

    void *visit(action_c *symbol) {return NULL;}

   482

   483

};/* generate_cc_sfc_transitionsort_c */

   484

   485

   486

   487

   488

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

   489

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

   490

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

   491

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

   492

   493

class generate_cc_sfc_stepassociation_c: public generate_cc_base_c {

   494

   495

  private:

   496

    symbol_c *current_step;

   497

    symbol_c *current_action;

   498

   499

  public:

   500

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