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

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

   296

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

   297

      if (current_array_type != NULL) {

   300

        current_array_type = NULL;

   301

      }

   302

      break;

   303

    default:

   304

      if (this->is_variable_prefix_null()) {

   305

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

   306

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

   307

    	if (current_array_type != NULL) {

   309

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

   310

    	  current_array_type = NULL;

   311

    	}

   312

      }

   313

      else

   314

    	print_getter(symbol);

   315

      break;

   316

  }

   317

  return NULL;

   318

}

   319

   320

/* subscript_list ',' subscript */

   321

void *visit(subscript_list_c *symbol) {

   322

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

   323

    s4o.print("[__");

   324

    current_array_type->accept(*this);

   325

    s4o.print("_TRANSIDX");

   326

    print_integer(i);

   327

    s4o.print("(");

   328

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

   329

    s4o.print(")]");

   330

  }

   331

  return NULL;

   332

}

   333

   334

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

   335

/* B 1.4.3 - Declaration & Initialisation */

   336

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

   340

void *visit(structure_element_initialization_list_c *symbol) {

   341

  generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);

   342

  structure_initialization->init_structure_default(this->current_param_type);

   344

  delete structure_initialization;

   345

  return NULL;

   346

}

   347

   358

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

   359

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

   360

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

   361

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

   362

/* B 3.1 - Expressions */

   363

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

   364

void *visit(or_expression_c *symbol) {

   365

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

   366

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

   367

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

   368

      ERROR;

   369

  if (search_expression_type->is_bool_type(left_type))

   370

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

   371

  if (search_expression_type->is_binary_type(left_type))

   372

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

   373

  ERROR;

   374

  return NULL;

   375

}

   376

   377

void *visit(xor_expression_c *symbol) {

   378

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

   379

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

   380

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

   381

      ERROR;

   382

  if (search_expression_type->is_bool_type(left_type)) {

   383

    s4o.print("(");

   384

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

   385

    s4o.print(" && !");

   386

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

   387

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

   388

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

   389

    s4o.print(" && ");

   390

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

   391

    s4o.print(")");

   392

    return NULL;

   393

  }

   394

  if (search_expression_type->is_binary_type(left_type))

   395

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

   396

  ERROR;

   397

  return NULL;

   398

}

   399

   400

void *visit(and_expression_c *symbol) {

   401

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

   402

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

   403

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

   404

      ERROR;

   405

  if (search_expression_type->is_bool_type(left_type))

   406

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

   407

  if (search_expression_type->is_binary_type(left_type))

   408

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

   409

  ERROR;

   410

  return NULL;

   411

}

   412

   413

void *visit(equ_expression_c *symbol) {

   414

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

   415

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

   416

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

   417

      ERROR;

   418

  if (search_expression_type->is_time_type(left_type) ||

   419

      search_expression_type->is_string_type(left_type))

   420

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

   421

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

   422

}

   423

   424

void *visit(notequ_expression_c *symbol) {

   425

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

   426

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

   427

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

   428

      ERROR;

   429

  if (search_expression_type->is_time_type(left_type) ||

   430

      search_expression_type->is_string_type(left_type))

   431

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

   432

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

   433

}

   434

   435

void *visit(lt_expression_c *symbol) {

   436

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

   437

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

   438

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

   439

      ERROR;

   440

  if (search_expression_type->is_time_type(left_type) ||

   441

      search_expression_type->is_string_type(left_type))

   442

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

   443

  if (!search_base_type.type_is_enumerated(left_type))

   444

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

   445

  ERROR;

   446

  return NULL;

   447

}

   448

   449

void *visit(gt_expression_c *symbol) {

   450

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

   451

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

   452

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

   453

      ERROR;

   454

  if (search_expression_type->is_time_type(left_type) ||

   455

      search_expression_type->is_string_type(left_type))

   456

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

   457

  if (!search_base_type.type_is_enumerated(left_type))

   458

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

   459

  ERROR;

   460

  return NULL;

   461

}

   462

   463

void *visit(le_expression_c *symbol) {

   464

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

   465

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

   466

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

   467

      ERROR;

   468

  if (search_expression_type->is_time_type(left_type) ||

   469

      search_expression_type->is_string_type(left_type))

   470

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

   471

  if (!search_base_type.type_is_enumerated(left_type))

   472

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

   473

  ERROR;

   474

  return NULL;

   475

}

   476

   477

void *visit(ge_expression_c *symbol) {

   478

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

   479

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

   480

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

   481

      ERROR;

   482

  if (search_expression_type->is_time_type(left_type) ||

   483

      search_expression_type->is_string_type(left_type))

   484

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

   485

  if (!search_base_type.type_is_enumerated(left_type))

   486

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

   487

  ERROR;

   488

  return NULL;

   489

}

   490

   491

void *visit(add_expression_c *symbol) {

   492

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

   493

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

   494

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

   495

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

   496

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

   497

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

   498

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

   499

      ERROR;

   500

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

   501

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

   502

  ERROR;

   503

  return NULL;

   504

}

   505