1

/*

     2

 * (c) 2003 Mario de Sousa

     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 st statements (i.e. ST code).

    28

 *

    29

 * This is part of the 4th stage that generates

    30

 * a c++ source program equivalent to the IL and ST

    31

 * code.

    32

 */

    33

    34

    35

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

    36

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

    37

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

    38

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

    39

    40

    41

class generate_c_st_c: public generate_c_typedecl_c {

    42

    43

  public:

    44

    typedef enum {

    45

      expression_vg,

    46

      assignment_vg,

    47

      complextype_base_vg,

    48

      complextype_suffix_vg,

    49

      fparam_output_vg

    50

    } variablegeneration_t;

    51

    52

  private:

    53

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

    54

     * by searching through the declarations of the variables currently

    55

     * in scope.

    56

     * This class does just that...

    57

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

    58

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

    59

     * This object instance will then later be called while the

    60

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

    61

     *

    62

     * Note that functions cannot contain calls to function blocks,

    63

     * so we do not create an object instance when handling

    64

     * a function declaration.

    65

     */

    66

    search_fb_instance_decl_c *search_fb_instance_decl;

    67

    68

    /* When compiling st code, it becomes necessary to determine the

    69

     * data type of st expressions. To do this, we must first find the

    70

     * st operand's declaration, within the scope of the function block

    71

     * or function currently being processed.

    72

     * The following object does just that...

    73

     * This object instance will then later be called while the

    74

     * remaining st code is being handled.

    75

     */

    76

    search_expression_type_c *search_expression_type;

    77

    78

    search_varfb_instance_type_c *search_varfb_instance_type;

    79

    80

    search_base_type_c search_base_type;

    81

    82

    symbol_c* current_array_type;

    83

    symbol_c* current_param_type;

    84

    85

    int fcall_number;

    86

    symbol_c *fbname;

    87

    88

    variablegeneration_t wanted_variablegeneration;

    89

    90

  public:

    91

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

    92

    : generate_c_typedecl_c(s4o_ptr) {

    93

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

    94

      search_expression_type = new search_expression_type_c(scope);

    95

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

    96

      this->set_variable_prefix(variable_prefix);

    97

      current_array_type = NULL;

    98

      current_param_type = NULL;

    99

      fcall_number = 0;

   100

      fbname = name;

   101

      wanted_variablegeneration = expression_vg;

   102

    }

   103

   104

    virtual ~generate_c_st_c(void) {

   105

      delete search_fb_instance_decl;

   106

      delete search_expression_type;

   107

      delete search_varfb_instance_type;

   108

    }

   109

   110

   111

  public:

   112

    void generate(statement_list_c *stl) {

   113

      stl->accept(*this);

   114

    }

   115

   116

  private:

   117

   118

void *print_getter(symbol_c *symbol) {

   119

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

   120

  if (wanted_variablegeneration == fparam_output_vg) {

   121

  	if (vartype == search_var_instance_decl_c::external_vt)

   122

      s4o.print(GET_EXTERNAL_BY_REF);

   123

    else if (vartype == search_var_instance_decl_c::located_vt)

   124

      s4o.print(GET_LOCATED_BY_REF);

   125

    else

   126

      s4o.print(GET_VAR_BY_REF);

   127

  }

   128

  else {

   129

	if (vartype == search_var_instance_decl_c::external_vt)

   130

	  s4o.print(GET_EXTERNAL);

   131

	else if (vartype == search_var_instance_decl_c::located_vt)

   132

	  s4o.print(GET_LOCATED);

   133

	else

   134

	  s4o.print(GET_VAR);

   135

  }

   136

  s4o.print("(");

   137

   138

  variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration;

   139

  wanted_variablegeneration = complextype_base_vg;

   140

  symbol->accept(*this);

   141

  if (search_varfb_instance_type->type_is_complex())

   142

    s4o.print(",");

   143

  wanted_variablegeneration = complextype_suffix_vg;

   144

  symbol->accept(*this);

   145

  s4o.print(")");

   146

  wanted_variablegeneration = old_wanted_variablegeneration;

   147

  return NULL;

   148

}

   149

   150

void *print_setter(symbol_c* symbol,

   151

		symbol_c* type,

   152

		symbol_c* value,

   153

		symbol_c* fb_symbol = NULL,

   154

		symbol_c* fb_value = NULL) {

   155

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

   156

  if (vartype == search_var_instance_decl_c::external_vt) {

   157

    symbolic_variable_c *variable = dynamic_cast<symbolic_variable_c *>(symbol);

   158

    /* TODO Find a solution for forcing global complex variables */

   159

    if (variable != NULL) {

   160

      s4o.print(SET_EXTERNAL);

   161

      s4o.print("(");

   162

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

   163

      s4o.print(",");

   164

    }

   165

    else {

   166

      s4o.print(SET_COMPLEX_EXTERNAL);

   167

      s4o.print("(");

   168

    }

   169

  }

   170

  else {

   171

    if (vartype == search_var_instance_decl_c::located_vt)

   172

      s4o.print(SET_LOCATED);

   173

    else

   174

      s4o.print(SET_VAR);

   175

    s4o.print("(");

   176

  }

   177

   178

  if (fb_symbol != NULL) {

   179

    print_variable_prefix();

   180

    fb_symbol->accept(*this);

   181

    s4o.print(".");

   182

  }

   183

  else

   184

    wanted_variablegeneration = complextype_base_vg;

   185

  symbol->accept(*this);

   186

  s4o.print(",");

   187

  wanted_variablegeneration = expression_vg;

   188

  print_check_function(type, value, fb_value);

   189

  if (search_varfb_instance_type->type_is_complex()) {

   190

    s4o.print(",");

   191

    wanted_variablegeneration = complextype_suffix_vg;

   192

    symbol->accept(*this);

   193

  }

   194

  s4o.print(")");

   195

  wanted_variablegeneration = expression_vg;

   196

  return NULL;

   197

}

   198

   199

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

   200

/* B 1.4 - Variables */

   201

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

   202

void *visit(symbolic_variable_c *symbol) {

   203

  unsigned int vartype;

   204

  if (wanted_variablegeneration == complextype_base_vg)

   205

	generate_c_base_c::visit(symbol);

   206

  else if (wanted_variablegeneration == complextype_suffix_vg)

   207

	return NULL;

   208

  else if (this->is_variable_prefix_null()) {

   209

	vartype = search_varfb_instance_type->get_vartype(symbol);

   210

	if (wanted_variablegeneration == fparam_output_vg) {

   211

	  s4o.print("&(");

   212

      generate_c_base_c::visit(symbol);

   213

      s4o.print(")");

   214

    }

   215

    else {

   216

      generate_c_base_c::visit(symbol);

   217

    }

   218

  }

   219

  else

   220

	print_getter(symbol);

   221

  return NULL;

   222

}

   223

   224

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

   225

/* B.1.4.1   Directly Represented Variables */

   226

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

   227

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

   228

void *visit(direct_variable_c *symbol) {

   229

  TRACE("direct_variable_c");

   230

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

   231

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

   232

  if (this->is_variable_prefix_null()) {

   233

    if (wanted_variablegeneration != fparam_output_vg)

   234

	  s4o.print("*(");

   235

  }

   236

  else {

   237

    switch (wanted_variablegeneration) {

   238

      case expression_vg:

   239

  	    s4o.print(GET_LOCATED);

   240

  	    s4o.print("(");

   241

  	    break;

   242

      case fparam_output_vg:

   243

        s4o.print(GET_LOCATED_BY_REF);

   244

        s4o.print("(");

   245

        break;

   246

      default:

   247

        break;

   248

    }

   249

  }

   250

  this->print_variable_prefix();

   251

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

   252

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

   253

	  wanted_variablegeneration != assignment_vg)

   254

    s4o.print(")");

   255

  return NULL;

   256

}

   257

   258

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

   259

/* B.1.4.2   Multi-element Variables */

   260

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

   261

   262

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   263

void *visit(structured_variable_c *symbol) {

   264

  TRACE("structured_variable_c");

   265

  switch (wanted_variablegeneration) {

   266

    case complextype_base_vg:

   267

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

   268

      break;

   269

    case complextype_suffix_vg:

   270

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

   271

      s4o.print(".");

   272

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

   273

      break;

   274

    default:

   275

      if (this->is_variable_prefix_null()) {

   276

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

   277

    	s4o.print(".");

   278

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

   279

      }

   280

      else

   281

    	print_getter(symbol);

   282

      break;

   283

  }

   284

  return NULL;

   285

}

   286

   287

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

   288

//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   289

void *visit(array_variable_c *symbol) {

   290

  switch (wanted_variablegeneration) {

   291

    case complextype_base_vg:

   292

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

   293

      break;

   294

    case complextype_suffix_vg:

   295

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

   296

   297

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

   298

      if (current_array_type == NULL) ERROR;

   299

   300

      s4o.print(".table");

   301

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

   302

   303

      current_array_type = NULL;

   304

      break;

   305

    default:

   306

      if (this->is_variable_prefix_null()) {

   307

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

   308

   309

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

   310

    	if (current_array_type == NULL) ERROR;

   311

   312

    	s4o.print(".table");

   313

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

   314

   315

        current_array_type = NULL;

   316

      }

   317

      else

   318

    	print_getter(symbol);

   319

      break;

   320

  }

   321

  return NULL;

   322

}

   323

   324

/* subscript_list ',' subscript */

   325

void *visit(subscript_list_c *symbol) {

   326

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

   327

    s4o.print("[__");

   328

    current_array_type->accept(*this);

   329

    s4o.print("_TRANSIDX");

   330

    print_integer(i);

   331

    s4o.print("(");

   332

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

   333

    s4o.print(")]");

   334

  }

   335

  return NULL;

   336

}

   337

   338

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

   339

/* B 1.4.3 - Declaration & Initialisation */

   340

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

   341

   342

/* helper symbol for structure_initialization */

   343

/* structure_element_initialization_list ',' structure_element_initialization */

   344

void *visit(structure_element_initialization_list_c *symbol) {

   345

  generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);

   346

  structure_initialization->init_structure_default(this->current_param_type);

   347

  structure_initialization->init_structure_values(symbol);

   348

  delete structure_initialization;

   349

  return NULL;

   350

}

   351

   352

/* helper symbol for array_initialization */

   353

/* array_initial_elements_list ',' array_initial_elements */

   354

void *visit(array_initial_elements_list_c *symbol) {

   355

  generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);

   356

  array_initialization->init_array_size(this->current_param_type);

   357

  array_initialization->init_array_values(symbol);

   358

  delete array_initialization;

   359

  return NULL;

   360

}

   361

   362

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

   363

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

   364

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

   365

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

   366

/* B 3.1 - Expressions */

   367

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

   368

void *visit(or_expression_c *symbol) {

   369

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   370

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   371

  if (!search_expression_type->is_same_type(left_type, right_type))

   372

      ERROR;

   373

  if (search_expression_type->is_bool_type(left_type))

   374

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

   375

  if (search_expression_type->is_binary_type(left_type))

   376

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

   377

  ERROR;

   378

  return NULL;

   379

}

   380

   381

void *visit(xor_expression_c *symbol) {

   382

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   383

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   384

  if (!search_expression_type->is_same_type(left_type, right_type))

   385

      ERROR;

   386

  if (search_expression_type->is_bool_type(left_type)) {

   387

    s4o.print("(");

   388

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

   389

    s4o.print(" && !");

   390

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

   391

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

   392

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

   393

    s4o.print(" && ");

   394

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

   395

    s4o.print(")");

   396

    return NULL;

   397

  }

   398

  if (search_expression_type->is_binary_type(left_type))

   399

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

   400

  ERROR;

   401

  return NULL;

   402

}

   403

   404

void *visit(and_expression_c *symbol) {

   405

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   406

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   407

  if (!search_expression_type->is_same_type(left_type, right_type))

   408

      ERROR;

   409

  if (search_expression_type->is_bool_type(left_type))

   410

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

   411

  if (search_expression_type->is_binary_type(left_type))

   412

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

   413

  ERROR;

   414

  return NULL;

   415

}

   416

   417

void *visit(equ_expression_c *symbol) {

   418

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   419

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   420

  if (!search_expression_type->is_same_type(left_type, right_type))

   421

      ERROR;

   422

  if (search_expression_type->is_time_type(left_type) ||

   423

      search_expression_type->is_string_type(left_type))

   424

    return print_compare_function("__eq_", left_type, symbol->l_exp, symbol->r_exp);

   425

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

   426

}

   427

   428

void *visit(notequ_expression_c *symbol) {

   429

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   430

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   431

  if (!search_expression_type->is_same_type(left_type, right_type))

   432

      ERROR;

   433

  if (search_expression_type->is_time_type(left_type) ||

   434

      search_expression_type->is_string_type(left_type))

   435

    return print_compare_function("__ne_", left_type, symbol->l_exp, symbol->r_exp);

   436

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

   437

}

   438

   439

void *visit(lt_expression_c *symbol) {

   440

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   441

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   442

  if (!search_expression_type->is_same_type(left_type, right_type))

   443

      ERROR;

   444

  if (search_expression_type->is_time_type(left_type) ||

   445

      search_expression_type->is_string_type(left_type))

   446

    return print_compare_function("__lt_", left_type, symbol->l_exp, symbol->r_exp);

   447

  if (!search_base_type.type_is_enumerated(left_type))

   448

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

   449

  ERROR;

   450

  return NULL;

   451

}

   452

   453

void *visit(gt_expression_c *symbol) {

   454

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   455

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   456

  if (!search_expression_type->is_same_type(left_type, right_type))

   457

      ERROR;

   458

  if (search_expression_type->is_time_type(left_type) ||

   459

      search_expression_type->is_string_type(left_type))

   460

    return print_compare_function("__gt_", left_type, symbol->l_exp, symbol->r_exp);

   461

  if (!search_base_type.type_is_enumerated(left_type))

   462

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

   463

  ERROR;

   464

  return NULL;

   465

}

   466

   467

void *visit(le_expression_c *symbol) {

   468

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   469

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   470

  if (!search_expression_type->is_same_type(left_type, right_type))

   471

      ERROR;

   472

  if (search_expression_type->is_time_type(left_type) ||

   473

      search_expression_type->is_string_type(left_type))

   474

    return print_compare_function("__le_", left_type, symbol->l_exp, symbol->r_exp);

   475

  if (!search_base_type.type_is_enumerated(left_type))

   476

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

   477

  ERROR;

   478

  return NULL;

   479

}

   480

   481

void *visit(ge_expression_c *symbol) {

   482

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   483

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   484

  if (!search_expression_type->is_same_type(left_type, right_type))

   485

      ERROR;

   486

  if (search_expression_type->is_time_type(left_type) ||

   487

      search_expression_type->is_string_type(left_type))

   488

    return print_compare_function("__ge_", left_type, symbol->l_exp, symbol->r_exp);

   489

  if (!search_base_type.type_is_enumerated(left_type))

   490

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

   491

  ERROR;

   492

  return NULL;

   493

}

   494

   495

void *visit(add_expression_c *symbol) {

   496

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   497

	symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   498

	if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||

   499

      (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||

   500

      (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)))

   501

    return print_binary_function("__TIME_ADD", symbol->l_exp, symbol->r_exp);

   502

  if (!search_expression_type->is_same_type(left_type, right_type))

   503

      ERROR;

   504

  if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))