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

    42

class generate_cc_sfc_steptable_c: public generate_cc_base_c {

    43

    44

  private:

    45

    char step_number;

    46

    47

  public:

    48

    generate_cc_sfc_steptable_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

    49

    ~generate_cc_sfc_steptable_c(void) {}

    50

    51

    void reset_step_number(void) {step_number = 0;}

    52

    void print_step_number(void) {

    53

      char str[10];

    54

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

    55

      s4o.print(str);

    56

    }

    57

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

    58

/* B.1.6  Sequential function chart elements */

    59

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

    60

    61

    void *visit(initial_step_c *symbol) {

    62

      if (step_number > 0) {

    63

        s4o.print(",\n");

    64

      }

    65

      s4o.print(s4o.indent_spaces + "{1, 0, 0}");

    66

      step_number++;

    67

      return NULL;

    68

    }

    69

    70

    void *visit(step_c *symbol) {

    71

      if (step_number > 0) {

    72

        s4o.print(",\n");

    73

      }

    74

      s4o.print(s4o.indent_spaces + "{0, 0, 0}");

    75

      step_number++;

    76

      return NULL;

    77

    }

    78

    79

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

    80

    81

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

    82

    83

}; /* generate_cc_sfc_steptable_c */

    84

    85

    86

    87

    88

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

    89

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

    90

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

    91

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

    92

    93

class generate_cc_sfc_actiontable_c: public generate_cc_base_c {

    94

    95

  private:

    96

    char action_number;

    97

    98

  public:

    99

    generate_cc_sfc_actiontable_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

   100

    ~generate_cc_sfc_actiontable_c(void) {}

   101

   102

    void reset_action_number(void) {action_number = 0;}

   103

    void print_action_number(void) {

   104

      char str[10];

   105

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

   106

      s4o.print(str);

   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) {return NULL;}

   117

   118

    void *visit(action_c *symbol) {

   119

      if (action_number > 0) {

   120

        s4o.print(",\n");

   121

      }

   122

      s4o.print(s4o.indent_spaces + "{0, 0, 0, 0, 0, 0}");

   123

      action_number++;

   124

      return NULL;

   125

    }

   126

   127

}; /* generate_cc_sfc_actiontable_c */

   128

   129

   130

   131

   132

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

   133

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

   134

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

   135

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

   136

   137

class generate_cc_sfc_transitiontable_c: public generate_cc_base_c {

   138

   139

  private:

   140

    char transition_number;

   141

   142

  public:

   143

    generate_cc_sfc_transitiontable_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

   144

    ~generate_cc_sfc_transitiontable_c(void) {}

   145

   146

    void reset_transition_number(void) {transition_number = 0;}

   147

    void print_transition_number(void) {

   148

      char str[10];

   149

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

   150

      s4o.print(str);

   151

    }

   152

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

   153

/* B.1.6  Sequential function chart elements */

   154

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

   155

   156

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

   157

   158

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

   159

   161

      transition_number++;

   162

      return NULL;

   163

    }

   164

   167

}; /* generate_cc_sfc_steptable_c */

   168

   169

   170

   171

   172

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

   173

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

   174

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

   175

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

   176

   177

class generate_cc_sfctables_c: public iterator_visitor_c {

   178

   179

  protected:

   180

    stage4out_c &s4o;

   181

   182

  private:

   183

    generate_cc_sfc_steptable_c *generate_cc_sfc_steptable;

   184

    generate_cc_sfc_actiontable_c *generate_cc_sfc_actiontable;

   185

    generate_cc_sfc_transitiontable_c *generate_cc_sfc_transitiontable;

   186

   187

  public:

   188

    generate_cc_sfctables_c(stage4out_c *s4o_ptr) : s4o(*s4o_ptr) {

   189

      generate_cc_sfc_steptable = new generate_cc_sfc_steptable_c(s4o_ptr);

   190

      generate_cc_sfc_actiontable = new generate_cc_sfc_actiontable_c(s4o_ptr);

   191

      generate_cc_sfc_transitiontable = new generate_cc_sfc_transitiontable_c(s4o_ptr);

   192

    }

   193

   194

    virtual ~generate_cc_sfctables_c(void) {

   195

      delete generate_cc_sfc_steptable;

   196

      delete generate_cc_sfc_actiontable;

   197

      delete generate_cc_sfc_transitiontable;

   198

    }

   199

   200

  public:

   201

   202

    /* generate steps and actions tables */

   203

    void *visit(sequential_function_chart_c *symbol) {

   204

      /* generate steps table */

   205

      generate_cc_sfc_steptable->reset_step_number();

   206

      s4o.print(s4o.indent_spaces + "STEP step_list[] = {\n");

   207

      s4o.indent_right();

   208

      symbol->accept(*generate_cc_sfc_steptable);

   209

      s4o.indent_left();

   210

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

   211

      generate_cc_sfc_steptable->print_step_number();

   212

      s4o.print(";\n");

   213

   214

      /* generate actions table */

   215

      generate_cc_sfc_actiontable->reset_action_number();

   216

      s4o.print(s4o.indent_spaces + "ACTION action_list[] = {\n");

   217

      s4o.indent_right();

   218

      symbol->accept(*generate_cc_sfc_actiontable);

   219

      s4o.indent_left();

   220

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

   221

      generate_cc_sfc_actiontable->print_action_number();

   222

      s4o.print(";\n");

   223

   225

      generate_cc_sfc_transitiontable->reset_transition_number();

   227

      s4o.print(s4o.indent_spaces + "char transition_list[");

   228

      generate_cc_sfc_transitiontable->print_transition_number();

   229

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

   230

   231

      return NULL;

   232

    }

   233

   234

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

   235

/* B 2.1 Instructions and Operands */

   236

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

   237

/*| instruction_list il_instruction */

   238

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

   239

   240

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

   241

/* B.3 - Language ST (Structured Text) */

   242

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

   243

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

   244

/* B 3.2 Statements */

   245

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

   246

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

   247

   248

/* Remainder implemented in generate_cc_sfcdecl_c... */

   249

};

   250

   251

   252

   253

   254

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

   255

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

   256

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

   257

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

   258

   259

class generate_cc_sfc_stepdecl_c: public generate_cc_base_c {

   260

   261

  private:

   262

    char step_number;

   263

   264

  public:

   265

    generate_cc_sfc_stepdecl_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

   266

    ~generate_cc_sfc_stepdecl_c(void) {}

   267

   268

    void reset_step_number(void) {step_number = 0;}

   269

    void print_step_number(void) {

   270

      char str[10];

   271

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

   272

      s4o.print(str);

   273

    }

   274

   275

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

   276

/* B.1.6  Sequential function chart elements */

   277

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

   278

   279

    void *visit(initial_step_c *symbol) {

   280

      s4o.print("#define ");

   281

      s4o.print(SFC_STEP_ACTION_PREFIX);

   282

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

   283

      s4o.print(" ");

   284

      print_step_number();

   285

      s4o.print("\n");

   286

      step_number++;

   287

      return NULL;

   288

    }

   289

   290

    void *visit(step_c *symbol) {

   291

      s4o.print("#define ");

   292

      s4o.print(SFC_STEP_ACTION_PREFIX);

   293

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

   294

      s4o.print(" ");

   295

      print_step_number();

   296

      s4o.print("\n");

   297

      step_number++;

   298

      return NULL;

   299

    }

   300

   301

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

   302

   303

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

   304

   305

}; /* generate_cc_sfc_stepdecl_c */

   306

   307

   308

   309

   310

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

   311

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

   312

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

   313

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

   314

   315

class generate_cc_sfc_actiondecl_c: public generate_cc_base_c {

   316

   317

  private:

   318

    char action_number;

   319

   320

  public:

   321

    generate_cc_sfc_actiondecl_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

   322

    ~generate_cc_sfc_actiondecl_c(void) {}

   323

   324

    void reset_action_number(void) {action_number = 0;}

   325

    void print_action_number(void) {

   326

      char str[10];

   327

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

   328

      s4o.print(str);

   329

    }

   330

   331

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

   332

/* B.1.6  Sequential function chart elements */

   333

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

   334

   335

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

   336

   337

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

   338

   339

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

   340

   341

    void *visit(action_c *symbol) {

   342

      s4o.print("#define ");

   343

      s4o.print(SFC_STEP_ACTION_PREFIX);

   344

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

   345

      s4o.print(" ");

   346

      print_action_number();

   347

      s4o.print("\n");

   348

      action_number++;

   349

      return NULL;

   350

    }

   351

   352

}; /* generate_cc_sfc_actiondecl_c */

   353

   354

   355

   356

   357

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

   358

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

   359

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

   360

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

   361

   362

class generate_cc_sfcdecl_c: public iterator_visitor_c {

   363

   364

  protected:

   365

    stage4out_c &s4o;

   366

   367

  private:

   368

    generate_cc_sfc_stepdecl_c *generate_cc_sfc_stepdecl;

   369

    generate_cc_sfc_actiondecl_c *generate_cc_sfc_actiondecl;

   370

   371

  public:

   372

    generate_cc_sfcdecl_c(stage4out_c *s4o_ptr) : s4o(*s4o_ptr) {

   373

      generate_cc_sfc_stepdecl = new generate_cc_sfc_stepdecl_c(s4o_ptr);

   374

      generate_cc_sfc_actiondecl = new generate_cc_sfc_actiondecl_c(s4o_ptr);

   375

    }

   376

   377

    virtual ~generate_cc_sfcdecl_c(void) {

   378

      delete generate_cc_sfc_stepdecl;

   379

      delete generate_cc_sfc_actiondecl;

   380

    }

   381

   382

  public:

   383

   384

    /* generate steps and actions tables */

   385

    void *visit(sequential_function_chart_c *symbol) {

   386

      /* generate steps definitions */

   387

      generate_cc_sfc_stepdecl->reset_step_number();

   388

      s4o.print("// Steps definitions\n");

   389

      symbol->accept(*generate_cc_sfc_stepdecl);

   390

      s4o.print("\n");

   391

   392

      /* generate actions definitions */

   393

      generate_cc_sfc_actiondecl->reset_action_number();

   394

      s4o.print("// Actions definitions\n");

   395

      symbol->accept(*generate_cc_sfc_actiondecl);

   396

      s4o.print("\n");

   397

   398

      return NULL;

   399

    }

   400

   401

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

   402

/* B 2.1 Instructions and Operands */

   403

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

   404

/*| instruction_list il_instruction */

   405

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

   406

   407

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

   408

/* B.3 - Language ST (Structured Text) */

   409

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

   410

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

   411

/* B 3.2 Statements */

   412

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

   413

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

   414

   415

/* Remainder implemented in generate_cc_sfcdecl_c... */

   416

};

   417

   418

   419

   420

   421

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

   422

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

   423

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

   424

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

   425

   426

class generate_cc_sfc_stepundecl_c: public generate_cc_base_c {

   427

   428

  public:

   429

    generate_cc_sfc_stepundecl_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

   430

    ~generate_cc_sfc_stepundecl_c(void) {}

   431

   432

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

   433

/* B.1.6  Sequential function chart elements */

   434

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

   435

   436

    void *visit(initial_step_c *symbol) {

   437

      s4o.print("#undef ");

   438

      s4o.print(SFC_STEP_ACTION_PREFIX);

   439

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

   440

      s4o.print("\n");

   441

      return NULL;

   442

    }

   443

   444

    void *visit(step_c *symbol) {

   445

      s4o.print("#undef ");

   446

      s4o.print(SFC_STEP_ACTION_PREFIX);

   447

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

   448

      s4o.print("\n");

   449

      return NULL;

   450

    }

   451

   452

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

   453

   454

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

   455

   456

}; /* generate_cc_sfc_stepdecl_c */

   457

   458

   459

   460

   461

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

   462

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

   463

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

   464

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

   465

   466

class generate_cc_sfc_actionundecl_c: public generate_cc_base_c {

   467

   468

  public:

   469

    generate_cc_sfc_actionundecl_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {}

   470

    ~generate_cc_sfc_actionundecl_c(void) {}

   471

   472

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

   473

/* B.1.6  Sequential function chart elements */

   474

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

   475

   476

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

   477

   478

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

   479

   480

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

   481

   482

    void *visit(action_c *symbol) {

   483

      s4o.print("#undef ");

   484

      s4o.print(SFC_STEP_ACTION_PREFIX);

   485

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

   486

      s4o.print("\n");

   487

      return NULL;

   488

    }

   489

   490

}; /* generate_cc_sfc_stepdecl_c */

   491

   492

   493

   494

   495

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

   496

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

   497

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

   498

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

   499

   500

class generate_cc_sfcundecl_c: public iterator_visitor_c {

   501

   502

  protected: