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) {

    52

      transition = tr;

    53

      priority = pr;

    54

      index = idx;

    55

    }

    56

    57

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

    58

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

    59

    transition_element *get_prev(void) {return prev;}

    60

    transition_element *get_next(void) {return next;}

    61

    transition_c *get_transition(void) {return transition;}

    62

    char get_priority(void) {return priority;}

    63

    char get_index(void) {return index;}

    64

};

    65

    66

    67

    68

    69

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

    70

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

    71

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

    72

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

    73

    74

class generate_cc_sfc_transitionresetsteps_c: public generate_cc_base_c {

    75

    76

  private:

    77

    char transition_number;

    78

    79

  public:

    80

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

    81

    : generate_cc_base_c(s4o_ptr) {

    82

      this->set_variable_prefix(variable_prefix);

    83

    }

    84

    85

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

    86

    void reset_transition_number(void) {transition_number = 0;}

    87

    void print_transition_number(void) {

    88

      char str[10];

    89

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

    90

      s4o.print(str);

    91

    }

    92

    93

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

    94

      print_variable_prefix();

    95

      s4o.print("step_list[");

    96

      s4o.print(SFC_STEP_ACTION_PREFIX);

    97

      step_name->accept(*this);

    98

      s4o.print("].");

    99

      s4o.print(argument);

   100

    }

   101

   102

    void print_reset_step(symbol_c *step_name) {

   103

      s4o.print(s4o.indent_spaces);

   104

      print_step_argument(step_name, "state");

   105

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

   106

    }

   107

   108

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

   109

/* B.1.6  Sequential function chart elements */

   110

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

   111

   112

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

   113

   114

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

   115

   116

    void *visit(transition_c *symbol) {

   117

      if (symbol->integer == NULL) {

   118

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

   119

        print_variable_prefix();

   120

        s4o.print("transition_list[");

   121

        print_transition_number();

   122

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

   123

        s4o.indent_right();

   124

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

   125

        s4o.indent_left();

   126

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

   127

      }

   128

      transition_number++;

   129

      return NULL;

   130

    }

   131

   132

    void *visit(steps_c *symbol) {

   133

      if (symbol->step_name != NULL) {

   134

        print_reset_step(symbol->step_name);

   135

      }

   136

      if (symbol->step_name_list != NULL) {

   137

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

   138

      }

   139

      return NULL;

   140

    }

   141

   142

    void *visit(step_name_list_c *symbol) {

   143

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

   144

        print_reset_step(symbol->elements[i]);

   145

      }

   146

      return NULL;

   147

    }

   148

   149

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

   150

   151

}; /* generate_cc_sfc_transitionresetsteps_c */

   152

   153

   154

   155

   156

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

   157

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

   158

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

   159

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

   160

   161

class generate_cc_sfc_transitionsetsteps_c: public generate_cc_base_c {

   162

   163

  private:

   164

    char transition_number;

   165

   166

  public:

   167

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

   168

    : generate_cc_base_c(s4o_ptr) {

   169

      this->set_variable_prefix(variable_prefix);

   170

    }

   171

   172

    void reset_transition_number(void) {transition_number = 0;}

   173

    void print_transition_number(void) {

   174

      char str[10];

   175

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

   176

      s4o.print(str);

   177

    }

   178

   179

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

   180

      print_variable_prefix();

   181

      s4o.print("step_list[");

   182

      s4o.print(SFC_STEP_ACTION_PREFIX);

   183

      step_name->accept(*this);

   184

      s4o.print("].");

   185

      s4o.print(argument);

   186

    }

   187

   188

    void print_set_step(symbol_c *step_name) {

   189

      s4o.print(s4o.indent_spaces);

   190

      print_step_argument(step_name, "state");

   191

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

   192

      print_step_argument(step_name, "elapsed_time");

   193

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

   194

    }

   195

   196

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

   197

/* B.1.6  Sequential function chart elements */

   198

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

   199

   200

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

   201

   202

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

   203

   204

    void *visit(transition_c *symbol) {

   205

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

   206

      print_variable_prefix();

   207

      s4o.print("transition_list[");

   208

      print_transition_number();

   209

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

   210

      s4o.indent_right();

   211

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

   212

      s4o.indent_left();

   213

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

   214

      transition_number++;

   215

      return NULL;

   216

    }

   217

   218

    void *visit(steps_c *symbol) {

   219

      if (symbol->step_name != NULL) {

   220

        print_set_step(symbol->step_name);

   221

      }

   222

      if (symbol->step_name_list != NULL) {

   223

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

   224

      }

   225

      return NULL;

   226

    }

   227

   228

    void *visit(step_name_list_c *symbol) {

   229

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

   230

        print_set_step(symbol->elements[i]);

   231

      }

   232

      return NULL;

   233

    }

   234

   235

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

   236

   237

}; /* generate_cc_sfc_transitionsetsteps_c */

   238

   239

   240

   241

   242

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

   243

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

   244

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

   245

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

   246

   247

class generate_cc_sfc_transitiontest_c: public generate_cc_base_c {

   248

   249

  private:

   250

    char transition_number;

   251

   252

  private:

   253

    generate_cc_il_c *generate_cc_il;

   254

    generate_cc_st_c *generate_cc_st;

   255

    generate_cc_sfc_transitionresetsteps_c *generate_cc_sfc_transitionresetsteps;

   256

   257

  public:

   258

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

   259

    : generate_cc_base_c(s4o_ptr) {

   260

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

   261

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

   262

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

   263

      this->set_variable_prefix(variable_prefix);

   264

    }

   265

   266

    ~generate_cc_sfc_transitiontest_c(void) {

   267

      delete generate_cc_il;

   268

      delete generate_cc_st;

   269

      delete generate_cc_sfc_transitionresetsteps;

   270

    }

   271

   272

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

   273

    void print_transition_number(void) {

   274

      char str[10];

   275

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

   276

      s4o.print(str);

   277

    }

   278

   279

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

   280

      print_variable_prefix();

   281

      s4o.print("step_list[");

   282

      s4o.print(SFC_STEP_ACTION_PREFIX);

   283

      step_name->accept(*this);

   284

      s4o.print("].");

   285

      s4o.print(argument);

   286

    }

   287

   288

    void print_reset_step(symbol_c *step_name) {

   289

      s4o.print(s4o.indent_spaces);

   290

      print_step_argument(step_name, "state");

   291

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

   292

    }

   293

   294

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

   295

/* B.1.6  Sequential function chart elements */

   296

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

   297

   298

    void *visit(transition_c *symbol) {

   299

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

   300

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

   301

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

   302

      s4o.indent_right();

   303

   304

      // Calculate transition value

   305

      if (symbol->transition_condition_il != NULL) {

   306

        generate_cc_il->declare_backup_variable();

   307

        s4o.print(s4o.indent_spaces);

   308

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

   309

        print_variable_prefix();

   310

        s4o.print("transition_list[");

   311

        print_transition_number();

   312

        s4o.print("] = ");

   313

        generate_cc_il->print_backup_variable();

   314

        s4o.print(";\n");

   315

      }

   316

      if (symbol->transition_condition_st != NULL) {

   317

        s4o.print(s4o.indent_spaces);

   318

        print_variable_prefix();

   319

        s4o.print("transition_list[");

   320

        print_transition_number();

   321

        s4o.print("] = ");

   322

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

   323

        s4o.print(";\n");

   324

      }

   325

      if (symbol->integer != NULL) {

   326

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

   327

        print_variable_prefix();

   328

        s4o.print("transition_list[");

   329

        print_transition_number();

   330

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

   331

        s4o.indent_right();

   332

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

   333

        s4o.indent_left();

   334

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

   335

      }

   336

      s4o.indent_left();

   337

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

   338

      s4o.indent_right();

   339

      s4o.print(s4o.indent_spaces);

   340

      print_variable_prefix();

   341

      s4o.print("transition_list[");

   342

      print_transition_number();

   343

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

   344

      s4o.indent_left();

   345

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

   346

   347

      transition_number++;

   348

      return NULL;

   349

    }

   350

   351

    void *visit(steps_c *symbol) {

   352

      if (symbol->step_name != NULL) {

   353

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

   354

      }

   355

      if (symbol->step_name_list != NULL) {

   356

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

   357

      }

   358

      return NULL;

   359

    }

   360

   361

    void *visit(step_name_list_c *symbol) {

   362

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

   363

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

   364

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

   365

          s4o.print(" && ");

   366

        }

   367

      }

   368

      return NULL;

   369

    }

   370

   371

}; /* generate_cc_sfc_transitiontest_c */

   372

   373

   374

   375

   376

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

   377

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

   378

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

   379

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

   380

   381

class generate_cc_sfc_transitionsort_c: public iterator_visitor_c {

   382

   383

  private:

   384

    char transition_number;

   385

    transition_element *first_transition;

   386

    transition_element *last_transition;

   387

   388

  private:

   389

    generate_cc_sfc_transitiontest_c *generate_cc_sfc_transitiontest;

   390

   391

  public:

   392

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

   393

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

   394

      first_transition = NULL;

   395

      last_transition = NULL;

   396

    }

   397

   398

    ~generate_cc_sfc_transitionsort_c(void) {

   399

      delete generate_cc_sfc_transitiontest;

   400

    }

   401

   402

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

   403

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

   404

      new_transition->set_prev(last_transition);

   405

      if (last_transition != NULL) {

   406

        last_transition->set_next(new_transition);

   407

      }

   408

      else {

   409

        first_transition = new_transition;

   410

      }

   411

      last_transition = new_transition;

   412

      transition_number++;

   413

    }

   414

   415

    void sort_transitions(void) {

   416

      int i, j;

   417

      transition_element *current_transition;

   418

      transition_element *next_transition;

   419

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

   420

        current_transition = first_transition;

   421

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

   422

          next_transition = current_transition->get_next();

   423

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

   424

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

   425

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

   426

            }

   427

            else {

   428

              first_transition = next_transition;

   429

            }

   430

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

   431

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

   432

            }

   433

            else {

   434

              last_transition = current_transition;

   435

            }

   436

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

   437

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

   438

            current_transition->set_prev(next_transition);

   439

            next_transition->set_next(current_transition);

   440

          }

   441

          else {

   442

            current_transition = next_transition;

   443

          }

   444

        }

   445

      }

   446

    }

   447

   448

    void reset_transition_number(void) {transition_number = 0;}

   449

   450

    void generate(symbol_c *symbol) {

   451

      symbol->accept(*this);

   452

      sort_transitions();

   453

      transition_element *next_transition = first_transition;

   454

      while (next_transition != NULL) {

   455

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

   456

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

   457

        next_transition = next_transition->get_next();

   458

      }

   459

    }

   460

   461

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

   462

/* B.1.6  Sequential function chart elements */

   463

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

   464

   465

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

   466

   467

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

   468

   469

    void *visit(transition_c *symbol) {

   470

      if (symbol->integer != NULL) {

   471

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

   472

      }

   473

      else {

   474

        append_transition(symbol, 0, transition_number);

   475

      }

   476

      return NULL;

   477

    }

   478

   479

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

   480

   481

};/* generate_cc_sfc_transitionsort_c */

   482

   483

   484

   485

   486

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

   487

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

   488

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

   489

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

   490

   491

class generate_cc_sfc_stepassociation_c: public generate_cc_base_c {

   492

   493

  private:

   494

    symbol_c *current_step;

   495

    symbol_c *current_action;

   496

   497

  public:

   498

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

   499

    : generate_cc_base_c(s4o_ptr) {

   500

      this->set_variable_prefix(variable_prefix);