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

  identifier_c *symbol;

    28

} VARIABLE;

    29

    30

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

    31

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

    32

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

    33

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

    34

    35

class generate_c_sfcdecl_c: protected generate_c_base_and_typeid_c {

    36

    37

  public:

    38

      typedef enum {

    39

        sfcdecl_sd,

    40

        sfcinit_sd,

    41

        stepcount_sd,

    42

        stepdef_sd,

    43

        stepundef_sd,

    44

        actiondef_sd,

    45

        actionundef_sd,

    46

        actioncount_sd,

    47

        transitioncount_sd

    48

       } sfcdeclaration_t;

    49

    50

  private:

    51

    int step_number;

    52

    int action_number;

    53

    int transition_number;

    54

    std::list<VARIABLE> variable_list;

    55

    56

    sfcdeclaration_t wanted_sfcdeclaration;

    57

    58

    search_var_instance_decl_c *search_var_instance_decl;

    59

    60

  public:

    61

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

    62

    : generate_c_base_and_typeid_c(s4o_ptr) {

    63

      this->set_variable_prefix(variable_prefix);

    64

      search_var_instance_decl = new search_var_instance_decl_c(scope);

    65

    }

    66

    ~generate_c_sfcdecl_c(void) {

    67

      variable_list.clear();

    68

      delete search_var_instance_decl;

    69

    }

    70

    71

    void generate(symbol_c *symbol, sfcdeclaration_t declaration_type) {

    72

      wanted_sfcdeclaration = declaration_type;

    73

    74

      symbol->accept(*this);

    75

    }

    76

    77

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

    78

/* B.1.6  Sequential function chart elements */

    79

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

    80

    81

    void *visit(sequential_function_chart_c *symbol) {

    82

      step_number = 0;

    83

      action_number = 0;

    84

      transition_number = 0;

    85

      switch (wanted_sfcdeclaration) {

    86

        case sfcdecl_sd:

    87

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

    88

            symbol->get_element(i)->accept(*this);

    89

    90

          /* steps table declaration */

    91

          s4o.print(s4o.indent_spaces + "STEP __step_list[");

    92

          s4o.print(step_number);

    93

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

    94

          s4o.print(s4o.indent_spaces + "UINT __nb_steps;\n");

    95

    96

          /* actions table declaration */

    97

          s4o.print(s4o.indent_spaces + "ACTION __action_list[");

    98

          s4o.print(action_number);

    99

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

   100

          s4o.print(s4o.indent_spaces + "UINT __nb_actions;\n");

   101

   102

          /* transitions table declaration */

   103

          s4o.print(s4o.indent_spaces + "__IEC_BOOL_t __transition_list[");

   104

          s4o.print(transition_number);

   105

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

   106

   107

          /* transitions debug table declaration */

   108

          s4o.print(s4o.indent_spaces + "__IEC_BOOL_t __debug_transition_list[");

   109

          s4o.print(transition_number);

   110

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

   111

          s4o.print(s4o.indent_spaces + "UINT __nb_transitions;\n");

   112

   113

          /* last_ticktime declaration */

   114

          s4o.print(s4o.indent_spaces + "TIME __lasttick_time;\n");

   115

          break;

   116

        case sfcinit_sd:

   117

          s4o.print(s4o.indent_spaces);

   118

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

   119

   120

          /* steps table count */

   121

          wanted_sfcdeclaration = stepcount_sd;

   122

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

   123

            symbol->get_element(i)->accept(*this);

   124

          s4o.print(s4o.indent_spaces);

   125

          print_variable_prefix();

   126

          s4o.print("__nb_steps = ");

   127

          s4o.print(step_number);

   128

          s4o.print(";\n");

   129

          step_number = 0;

   130

          wanted_sfcdeclaration = sfcinit_sd;

   131

   132

          /* steps table initialisation */

   133

          s4o.print(s4o.indent_spaces + "static const STEP temp_step = {{0, 0}, 0, {{0, 0}, 0}};\n");

   134

          s4o.print(s4o.indent_spaces + "for(i = 0; i < ");

   135

          print_variable_prefix();

   136

          s4o.print("__nb_steps; i++) {\n");

   137

          s4o.indent_right();

   138

          s4o.print(s4o.indent_spaces);

   139

          print_variable_prefix();

   140

          s4o.print("__step_list[i] = temp_step;\n");

   141

          s4o.indent_left();

   142

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

   143

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

   144

            symbol->get_element(i)->accept(*this);

   145

   146

          /* actions table count */

   147

          wanted_sfcdeclaration = actioncount_sd;

   148

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

   149

            symbol->get_element(i)->accept(*this);

   150

          s4o.print(s4o.indent_spaces);

   151

          print_variable_prefix();

   152

          s4o.print("__nb_actions = ");

   153

          s4o.print(action_number);

   154

          s4o.print(";\n");

   155

          action_number = 0;

   156

          wanted_sfcdeclaration = sfcinit_sd;

   157

   158

          /* actions table initialisation */

   159

          s4o.print(s4o.indent_spaces + "static const ACTION temp_action = {0, {0, 0}, 0, 0, {0, 0}, {0, 0}};\n");

   160

          s4o.print(s4o.indent_spaces + "for(i = 0; i < ");

   161

          print_variable_prefix();

   162

          s4o.print("__nb_actions; i++) {\n");

   163

          s4o.indent_right();

   164

          s4o.print(s4o.indent_spaces);

   165

          print_variable_prefix();

   166

          s4o.print("__action_list[i] = temp_action;\n");

   167

          s4o.indent_left();

   168

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

   169

   170

          /* transitions table count */

   171

          wanted_sfcdeclaration = transitioncount_sd;

   172

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

   173

            symbol->get_element(i)->accept(*this);

   174

          s4o.print(s4o.indent_spaces);

   175

          print_variable_prefix();

   176

          s4o.print("__nb_transitions = ");

   177

          s4o.print(transition_number);

   178

          s4o.print(";\n");

   179

          transition_number = 0;

   180

          wanted_sfcdeclaration = sfcinit_sd;

   181

   182

          /* last_ticktime initialisation */

   183

          s4o.print(s4o.indent_spaces);

   184

          print_variable_prefix();

   185

          s4o.print("__lasttick_time = __CURRENT_TIME;\n");

   186

          break;

   187

        case stepdef_sd:

   188

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

   189

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

   190

            symbol->get_element(i)->accept(*this);

   191

          s4o.print("\n");

   192

          break;

   193

        case actiondef_sd:

   194

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

   195

          {

   196

            // first fill up the this->variable_list variable!

   197

            wanted_sfcdeclaration = actioncount_sd;

   198

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

   199

               symbol->get_element(i)->accept(*this);

   200

            action_number = 0; // reset the counter!

   201

            wanted_sfcdeclaration = actiondef_sd;

   202

            // Now do the defines for actions!

   203

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

   204

              symbol->get_element(i)->accept(*this);

   205

            // Now do the defines for actions that reference a variable instead of an action block!

   206

            std::list<VARIABLE>::iterator pt;

   207

            for(pt = variable_list.begin(); pt != variable_list.end(); pt++) {

   208

              s4o.print("#define ");

   209

              s4o.print(SFC_STEP_ACTION_PREFIX);

   210

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

   211

              s4o.print(" ");

   212

              s4o.print(action_number);

   213

              s4o.print("\n");

   214

              action_number++;

   215

            }

   216

          }

   217

          s4o.print("\n");

   218

          break;

   219

        case stepundef_sd:

   220

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

   221

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

   222

            symbol->get_element(i)->accept(*this);

   223

          s4o.print("\n");

   224

          break;

   225

        case actionundef_sd:

   226

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

   227

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

   228

            symbol->get_element(i)->accept(*this);

   229

          {

   230

            // first fill up the this->variable_list variable!

   231

            wanted_sfcdeclaration = actioncount_sd;

   232

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

   233

               symbol->get_element(i)->accept(*this);

   234

            wanted_sfcdeclaration = actionundef_sd;

   235

            std::list<VARIABLE>::iterator pt;

   236

            for(pt = variable_list.begin(); pt != variable_list.end(); pt++) {

   237

              s4o.print("#undef ");

   238

              s4o.print(SFC_STEP_ACTION_PREFIX);

   239

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

   240

              s4o.print("\n");

   241

            }

   242

          }

   243

          s4o.print("\n");

   244

          break;

   245

        default:

   246

          break;

   247

      }

   248

      return NULL;

   249

    }

   250

   251

    void *visit(initial_step_c *symbol) {

   252

      switch (wanted_sfcdeclaration) {

   253

        case actioncount_sd:

   254

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

   255

          break;

   256

        case sfcdecl_sd:

   257

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

   258

        case stepcount_sd:

   259

          step_number++;

   260

          break;

   261

        case sfcinit_sd:

   262

          s4o.print(s4o.indent_spaces);

   263

          s4o.print(SET_VAR);

   264

          s4o.print("(");

   265

          print_variable_prefix();

   266

          s4o.print(",__step_list[");

   267

          s4o.print(step_number);

   268

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

   269

          step_number++;

   270

          break;

   271

        case stepdef_sd:

   272

          s4o.print("#define ");

   273

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

   274

          s4o.print(" __step_list[");

   275

          s4o.print(step_number);

   276

          s4o.print("]\n");

   277

   278

          s4o.print("#define ");

   279

          s4o.print(SFC_STEP_ACTION_PREFIX);

   280

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

   281

          s4o.print(" ");

   282

          s4o.print(step_number);

   283

          s4o.print("\n");

   284

          step_number++;

   285

          break;

   286

        case stepundef_sd:

   287

          s4o.print("#undef ");

   288

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

   289

          s4o.print("\n");

   290

   291

          s4o.print("#undef ");

   292

          s4o.print(SFC_STEP_ACTION_PREFIX);

   293

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

   294

          s4o.print("\n");

   295

          break;

   296

        default:

   297

          break;

   298

      }

   299

      return NULL;

   300

    }

   301

   302

    void *visit(step_c *symbol) {

   303

      switch (wanted_sfcdeclaration) {

   304

        case actioncount_sd:

   305

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

   306

          break;

   307

        case sfcdecl_sd:

   308

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

   309

        case stepcount_sd:

   310

        case sfcinit_sd:

   311

          step_number++;

   312

          break;

   313

        case stepdef_sd:

   314

          s4o.print("#define ");

   315

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

   316

          s4o.print(" __step_list[");

   317

          s4o.print(step_number);

   318

          s4o.print("]\n");

   319

   320

          s4o.print("#define ");

   321

          s4o.print(SFC_STEP_ACTION_PREFIX);

   322

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

   323

          s4o.print(" ");

   324

          s4o.print(step_number);

   325

          s4o.print("\n");

   326

          step_number++;

   327

          break;

   328

        case stepundef_sd:

   329

          s4o.print("#undef ");

   330

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

   331

          s4o.print("\n");

   332

   333

          s4o.print("#undef ");

   334

          s4o.print(SFC_STEP_ACTION_PREFIX);

   335

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

   336

          s4o.print("\n");

   337

          break;

   338

        default:

   339

          break;

   340

      }

   341

      return NULL;

   342

    }

   343

   344

    void *visit(action_association_c *symbol) {

   345

      /* we try to find the variable instance declaration, to determine if symbol is variable... */

   346

      symbol_c *var_decl = search_var_instance_decl->get_decl(symbol->action_name);

   347

      if (var_decl != NULL) {

   348

        std::list<VARIABLE>::iterator pt;

   349

        for(pt = variable_list.begin(); pt != variable_list.end(); pt++) {

   350

          if (!compare_identifiers(pt->symbol, symbol->action_name))

   351

            return NULL;

   352

        }

   353

        VARIABLE *variable;

   354

        variable = new VARIABLE;

   355

        variable->symbol = (identifier_c*)(symbol->action_name);

   356

        variable_list.push_back(*variable);

   357

        action_number++;

   358

      }

   359

      return NULL;

   360

    }

   361

   362

    void *visit(transition_c *symbol) {

   363

      switch (wanted_sfcdeclaration) {

   364

        case sfcdecl_sd:

   365

        case transitioncount_sd:

   366

          transition_number++;

   367

          break;

   368

        default:

   369

          break;

   370

      }

   371

      return NULL;

   372

    }

   373

   374

    void *visit(action_c *symbol) {

   375

      switch (wanted_sfcdeclaration) {

   376

        case actiondef_sd:

   377

          s4o.print("#define ");

   378

          s4o.print(SFC_STEP_ACTION_PREFIX);

   379

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

   380

          s4o.print(" ");

   381

          s4o.print(action_number);

   382

          s4o.print("\n");

   383

          action_number++;

   384

          break;

   385

        case actionundef_sd:

   386

          s4o.print("#undef ");

   387

          s4o.print(SFC_STEP_ACTION_PREFIX);

   388

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

   389

          s4o.print("\n");

   390

          break;

   391

        case actioncount_sd:

   392

        case sfcdecl_sd:

   393

          action_number++;

   394

          break;

   395

        default:

   396

          break;

   397

      }

   398

      return NULL;

   399

    }

   400

   401

    void *visit(instruction_list_c *symbol) {

   402

      return NULL;

   403

    }

   404

   405

    void *visit(statement_list_c *symbol) {

   406

      return NULL;

   407

    }

   408

   409

}; /* generate_c_sfcdecl_c */

   410