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

 * This code is made available on the understanding that it will not be

    21

 * used in safety-critical situations without a full and competent review.

    22

 *

    23

 * Based on the

    24

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    25

 *

    26

 */

    27

    28

    29

/*

    30

 * Conversion of st statements (i.e. ST code).

    31

 *

    32

 * This is part of the 4th stage that generates

    33

 * a C source program equivalent to the IL and ST, or SFC

    34

 * code.

    35

 */

    36

    37

    38

    39

#include "../../util/strdup.hh"

    40

    41

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

    42

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

    43

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

    44

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

    45

    46

    47

class generate_c_st_c: public generate_c_typedecl_c {

    48

    49

  public:

    50

    typedef enum {

    51

      expression_vg,

    52

      assignment_vg,

    53

      complextype_base_vg,

    54

      complextype_base_assignment_vg,

    55

      complextype_suffix_vg,

    56

      fparam_output_vg

    57

    } variablegeneration_t;

    58

    59

    typedef enum {

    60

      single_cg,

    61

      subrange_cg,

    62

      none_cg

    63

    } casegeneration_t;

    64

    65

  private:

    66

    /* When calling a function block, we must first find it's type,

    67

     * by searching through the declarations of the variables currently

    68

     * in scope.

    69

     * This class does just that...

    70

     * A new class is instantiated whenever we begin generating the code

    71

     * for a function block type declaration, or a program declaration.

    72

     * This object instance will then later be called while the

    73

     * function block's or the program's body is being handled.

    74

     *

    75

     * Note that functions cannot contain calls to function blocks,

    76

     * so we do not create an object instance when handling

    77

     * a function declaration.

    78

     */

    79

    search_fb_instance_decl_c *search_fb_instance_decl;

    80

    81

    search_varfb_instance_type_c *search_varfb_instance_type;

    82

    search_var_instance_decl_c   *search_var_instance_decl;

    83

    84

    symbol_c* current_array_type;

    85

    symbol_c* current_param_type;

    86

    87

    int fcall_number;

    88

    symbol_c *fbname;

    89

    90

    bool first_subrange_case_list;

    91

    92

    variablegeneration_t wanted_variablegeneration;

    93

    casegeneration_t wanted_casegeneration;

    94

    95

  public:

    96

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

    97

    : generate_c_typedecl_c(s4o_ptr) {

    98

      search_fb_instance_decl    = new search_fb_instance_decl_c   (scope);

    99

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

   100

      search_var_instance_decl   = new search_var_instance_decl_c  (scope);

   101

   102

      this->set_variable_prefix(variable_prefix);

   103

      current_array_type = NULL;

   104

      current_param_type = NULL;

   105

      fcall_number = 0;

   106

      fbname = name;

   107

      wanted_variablegeneration = expression_vg;

   108

      wanted_casegeneration = none_cg;

   109

    }

   110

   111

    virtual ~generate_c_st_c(void) {

   112

      delete search_fb_instance_decl;

   113

      delete search_varfb_instance_type;

   114

      delete search_var_instance_decl;

   115

    }

   116

   117

   118

  public:

   119

    void generate(statement_list_c *stl) {

   120

      stl->accept(*this);

   121

    }

   122

   123

  private:

   124

   125

   126

   127

   128

   129

   130

void *print_getter(symbol_c *symbol) {

   131

  unsigned int vartype = search_var_instance_decl->get_vartype(symbol);

   132

  if (wanted_variablegeneration == fparam_output_vg) {

   133

    if (vartype == search_var_instance_decl_c::external_vt)

   134

      s4o.print(GET_EXTERNAL_BY_REF);

   135

    else if (vartype == search_var_instance_decl_c::located_vt)

   136

      s4o.print(GET_LOCATED_BY_REF);

   137

    else

   138

      s4o.print(GET_VAR_BY_REF);

   139

  }

   140

  else {

   141

    if (vartype == search_var_instance_decl_c::external_vt)

   142

      s4o.print(GET_EXTERNAL);

   143

    else if (vartype == search_var_instance_decl_c::located_vt)

   144

      s4o.print(GET_LOCATED);

   145

    else

   146

      s4o.print(GET_VAR);

   147

  }

   148

  s4o.print("(");

   149

   150

  variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration;

   151

  wanted_variablegeneration = complextype_base_vg;

   152

  symbol->accept(*this);

   153

  if (search_var_instance_decl->type_is_complex(symbol))

   154

    s4o.print(",");

   155

  wanted_variablegeneration = complextype_suffix_vg;

   156

  symbol->accept(*this);

   157

  s4o.print(")");

   158

  wanted_variablegeneration = old_wanted_variablegeneration;

   159

  return NULL;

   160

}

   161

   162

void *print_setter(symbol_c* symbol,

   163

		symbol_c* type,

   164

		symbol_c* value,

   165

		symbol_c* fb_symbol = NULL,

   166

		symbol_c* fb_value = NULL) {

   167

   168

  bool type_is_complex = false;

   169

  if (fb_symbol == NULL) {

   170

    unsigned int vartype = search_var_instance_decl->get_vartype(symbol);

   171

    type_is_complex = search_var_instance_decl->type_is_complex(symbol);

   172

    if (vartype == search_var_instance_decl_c::external_vt)

   173

      s4o.print(SET_EXTERNAL);

   174

    else if (vartype == search_var_instance_decl_c::located_vt)

   175

      s4o.print(SET_LOCATED);

   176

    else

   177

      s4o.print(SET_VAR);

   178

  }

   179

  else

   180

	s4o.print(SET_VAR);

   181

  s4o.print("(");

   182

   183

  if (fb_symbol != NULL) {

   184

    print_variable_prefix();

   185

    fb_symbol->accept(*this);

   186

    s4o.print(".,");

   187

  }

   188

  else if (type_is_complex)

   189

    wanted_variablegeneration = complextype_base_assignment_vg;

   190

  else

   191

    wanted_variablegeneration = assignment_vg;

   192

   193

  symbol->accept(*this);

   194

  s4o.print(",");

   195

  wanted_variablegeneration = expression_vg;

   196

  print_check_function(type, value, fb_value);

   197

  if (type_is_complex) {

   198

    s4o.print(",");

   199

    wanted_variablegeneration = complextype_suffix_vg;

   200

    symbol->accept(*this);

   201

  }

   202

  s4o.print(")");

   203

  wanted_variablegeneration = expression_vg;

   204

  return NULL;

   205

}

   206

   207

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

   208

/* B 1.3.3 - Derived data types */

   209

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

   210

   211

/*  signed_integer DOTDOT signed_integer */

   212

void *visit(subrange_c *symbol) {

   213

  switch (wanted_casegeneration) {

   214

    case subrange_cg:

   215

      s4o.print("__case_expression >= ");

   216

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

   217

      s4o.print(" && __case_expression <= ");

   218

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

   219

      break;

   220

    default:

   221

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

   222

      break;

   223

  }

   224

  return NULL;

   225

}

   226

   227

/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */

   228

void *visit(array_specification_c *symbol) {

   229

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

   230

  return NULL;

   231

}

   232

   233

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

   234

/* B 1.4 - Variables */

   235

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

   236

void *visit(symbolic_variable_c *symbol) {

   237

  switch (wanted_variablegeneration) {

   238

    case complextype_base_assignment_vg:

   239

    case assignment_vg:

   240

      this->print_variable_prefix();

   241

      s4o.print(",");

   242

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

   243

      break;

   244

    case complextype_base_vg:

   245

      generate_c_base_c::visit(symbol);

   246

      break;

   247

    case complextype_suffix_vg:

   248

      break;

   249

    default:

   250

      if (this->is_variable_prefix_null()) {

   251

        if (wanted_variablegeneration == fparam_output_vg) {

   252

          s4o.print("&(");

   253

          generate_c_base_c::visit(symbol);

   254

          s4o.print(")");

   255

        }

   256

        else {

   257

          generate_c_base_c::visit(symbol);

   258

        }

   259

      }

   260

      else

   261

        print_getter(symbol);

   262

      break;

   263

  }

   264

  return NULL;

   265

}

   266

   267

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

   268

/* B.1.4.1   Directly Represented Variables */

   269

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

   270

// direct_variable: direct_variable_token   {$$ = new direct_variable_c($1);};

   271

void *visit(direct_variable_c *symbol) {

   272

  TRACE("direct_variable_c");

   273

  /* Do not use print_token() as it will change everything into uppercase */

   274

  if (strlen(symbol->value) == 0) ERROR;

   275

  if (this->is_variable_prefix_null()) {

   276

    if (wanted_variablegeneration != fparam_output_vg)

   277

	  s4o.print("*(");

   278

  }

   279

  else {

   280

    switch (wanted_variablegeneration) {

   281

      case expression_vg:

   282

  	    s4o.print(GET_LOCATED);

   283

  	    s4o.print("(");

   284

  	    break;

   285

      case fparam_output_vg:

   286

        s4o.print(GET_LOCATED_BY_REF);

   287

        s4o.print("(");

   288

        break;

   289

      default:

   290

        break;

   291

    }

   292

  }

   293

  this->print_variable_prefix();

   294

  s4o.printlocation(symbol->value + 1);

   295

  if ((this->is_variable_prefix_null() && wanted_variablegeneration != fparam_output_vg) ||

   296

	  wanted_variablegeneration != assignment_vg)

   297

    s4o.print(")");

   298

  return NULL;

   299

}

   300

   301

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

   302

/* B.1.4.2   Multi-element Variables */

   303

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

   304

   305

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   306

void *visit(structured_variable_c *symbol) {

   307

  TRACE("structured_variable_c");

   308

  bool type_is_complex = search_var_instance_decl->type_is_complex(symbol->record_variable);

   309

  switch (wanted_variablegeneration) {

   310

    case complextype_base_vg:

   311

    case complextype_base_assignment_vg:

   312

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

   313

      if (!type_is_complex) {

   314

    	s4o.print(".");

   315

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

   316

      }

   317

      break;

   318

    case complextype_suffix_vg:

   319

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

   320

      if (type_is_complex) {

   321

        s4o.print(".");

   322

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

   323

      }

   324

      break;

   325

    case assignment_vg:

   326

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

   327

      s4o.print(".");

   328

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

   329

      break;

   330

    default:

   331

      if (this->is_variable_prefix_null()) {

   332

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

   333

    	s4o.print(".");

   334

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

   335

      }

   336

      else

   337

    	print_getter(symbol);

   338

      break;

   339

  }

   340

  return NULL;

   341

}

   342

   343

/*  subscripted_variable '[' subscript_list ']' */

   344

//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   345

void *visit(array_variable_c *symbol) {

   346

  switch (wanted_variablegeneration) {

   347

    case complextype_base_vg:

   348

    case complextype_base_assignment_vg:

   349

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

   350

      break;

   351

    case complextype_suffix_vg:

   352

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

   353

   354

      current_array_type = search_varfb_instance_type->get_basetype_decl(symbol->subscripted_variable);

   355

      if (current_array_type == NULL) ERROR;

   356

   357

      s4o.print(".table");

   358

      wanted_variablegeneration = expression_vg;

   359

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

   360

      wanted_variablegeneration = complextype_suffix_vg;

   361

   362

      current_array_type = NULL;

   363

      break;

   364

    default:

   365

      if (this->is_variable_prefix_null()) {

   366

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

   367

   368

    	current_array_type = search_varfb_instance_type->get_basetype_decl(symbol->subscripted_variable);

   369

    	if (current_array_type == NULL) ERROR;

   370

   371

    	s4o.print(".table");

   372

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

   373

   374

        current_array_type = NULL;

   375

      }

   376

      else

   377

    	print_getter(symbol);

   378

      break;

   379

  }

   380

  return NULL;

   381

}

   382

   383

/* subscript_list ',' subscript */

   384

void *visit(subscript_list_c *symbol) {

   385

  array_dimension_iterator_c* array_dimension_iterator = new array_dimension_iterator_c(current_array_type);

   386

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

   387

    symbol_c* dimension = array_dimension_iterator->next();

   388

	if (dimension == NULL) ERROR;

   389

   390

	s4o.print("[(");

   391

    symbol->elements[i]->accept(*this);

   392

    s4o.print(") - (");

   393

    dimension->accept(*this);

   394

    s4o.print(")]");

   395

  }

   396

  delete array_dimension_iterator;

   397

  return NULL;

   398

}

   399

   400

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

   401

/* B 1.4.3 - Declaration & Initialisation */

   402

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

   403

   404

/* helper symbol for structure_initialization */

   405

/* structure_element_initialization_list ',' structure_element_initialization */

   406

void *visit(structure_element_initialization_list_c *symbol) {

   407

  generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);

   408

  structure_initialization->init_structure_default(this->current_param_type);

   409

  structure_initialization->init_structure_values(symbol);

   410

  delete structure_initialization;

   411

  return NULL;

   412

}

   413

   414

/* helper symbol for array_initialization */

   415

/* array_initial_elements_list ',' array_initial_elements */

   416

void *visit(array_initial_elements_list_c *symbol) {

   417

  generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);

   418

  array_initialization->init_array_size(this->current_param_type);

   419

  array_initialization->init_array_values(symbol);

   420

  delete array_initialization;

   421

  return NULL;

   422

}

   423

   424

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

   425

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

   426

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

   427

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

   428

/* B 3.1 - Expressions */

   429

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

   430

void *visit(or_expression_c *symbol) {

   431

  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype))

   432

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " || ");

   433

  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))

   434

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " | ");

   435

  ERROR;

   436

  return NULL;

   437

}

   438

   439

void *visit(xor_expression_c *symbol) {

   440

  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype)) {

   441

    s4o.print("(");

   442

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

   443

    s4o.print(" && !");

   444

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

   445

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

   446

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

   447

    s4o.print(" && ");

   448

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

   449

    s4o.print(")");

   450

    return NULL;

   451

  }

   452

  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))

   453

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " ^ ");

   454

  ERROR;

   455

  return NULL;

   456

}

   457

   458

void *visit(and_expression_c *symbol) {

   459

  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype))

   460

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " && ");

   461

  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))

   462

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " & ");

   463

  ERROR;

   464

return NULL;

   465

}

   466

   467

void *visit(equ_expression_c *symbol) {

   468

  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||

   469

      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||

   470

      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))

   471

    return print_compare_function("EQ_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);

   472

  return print_binary_expression(symbol->l_exp, symbol->r_exp, " == ");

   473

}

   474

   475

void *visit(notequ_expression_c *symbol) {

   476

  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||

   477

      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||

   478

      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))

   479

    return print_compare_function("NE_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);

   480

  return print_binary_expression(symbol->l_exp, symbol->r_exp, " != ");

   481

}

   482

   483

void *visit(lt_expression_c *symbol) {

   484

  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||

   485

      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||

   486

      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))

   487

    return print_compare_function("LT_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);

   488

  return print_binary_expression(symbol->l_exp, symbol->r_exp, " < ");

   489

}

   490

   491

void *visit(gt_expression_c *symbol) {

   492

  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||

   493

      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||

   494

      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))