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

    84

    int fcall_number;

    85

    symbol_c *fbname;

    86

    87

    variablegeneration_t wanted_variablegeneration;

    88

    89

  public:

    90

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

    91

    : generate_c_typedecl_c(s4o_ptr) {

    92

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

    93

      search_expression_type = new search_expression_type_c(scope);

    94

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

    95

      this->set_variable_prefix(variable_prefix);

    96

      current_array_type = NULL;

    97

      fcall_number = 0;

    98

      fbname = name;

    99

      wanted_variablegeneration = expression_vg;

   100

    }

   101

   102

    virtual ~generate_c_st_c(void) {

   103

      delete search_fb_instance_decl;

   104

      delete search_expression_type;

   105

      delete search_varfb_instance_type;

   106

    }

   107

   108

   109

  public:

   110

    void generate(statement_list_c *stl) {

   111

      stl->accept(*this);

   112

    }

   113

   114

  private:

   115

   116

void *print_getter(symbol_c *symbol) {

   117

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

   118

  if (vartype == search_var_instance_decl_c::external_vt)

   119

	s4o.print(GET_EXTERNAL);

   120

  else if (vartype == search_var_instance_decl_c::located_vt)

   121

	s4o.print(GET_LOCATED);

   122

  else

   123

	s4o.print(GET_VAR);

   124

  s4o.print("(");

   125

   126

  wanted_variablegeneration = complextype_base_vg;

   127

  symbol->accept(*this);

   128

  if (search_varfb_instance_type->type_is_complex())

   129

	s4o.print(",");

   130

  wanted_variablegeneration = complextype_suffix_vg;

   131

  symbol->accept(*this);

   132

  s4o.print(")");

   133

  wanted_variablegeneration = expression_vg;

   134

  return NULL;

   135

}

   136

   137

void *print_setter(symbol_c* symbol,

   138

		symbol_c* type,

   139

		symbol_c* value,

   140

		symbol_c* fb_symbol = NULL,

   141

		symbol_c* fb_value = NULL) {

   142

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

   143

  if (vartype == search_var_instance_decl_c::external_vt)

   144

    s4o.print(SET_EXTERNAL);

   145

  else if (vartype == search_var_instance_decl_c::located_vt)

   146

    s4o.print(SET_LOCATED);

   147

  else

   148

    s4o.print(SET_VAR);

   149

  s4o.print("(");

   150

   151

  if (fb_symbol != NULL) {

   152

    print_variable_prefix();

   153

    fb_symbol->accept(*this);

   154

    s4o.print(".");

   155

  }

   156

  else

   157

    wanted_variablegeneration = complextype_base_vg;

   158

  symbol->accept(*this);

   159

  s4o.print(",");

   160

  wanted_variablegeneration = expression_vg;

   161

  print_check_function(type, value, fb_value);

   162

  if (search_varfb_instance_type->type_is_complex()) {

   163

    s4o.print(",");

   164

    wanted_variablegeneration = complextype_suffix_vg;

   165

    symbol->accept(*this);

   166

  }

   167

  s4o.print(")");

   168

  wanted_variablegeneration = expression_vg;

   169

  return NULL;

   170

}

   171

   172

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

   173

/* B 1.4 - Variables */

   174

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

   175

void *visit(symbolic_variable_c *symbol) {

   176

  unsigned int vartype;

   177

  if (wanted_variablegeneration == complextype_base_vg)

   178

	generate_c_base_c::visit(symbol);

   179

  else if (wanted_variablegeneration == complextype_suffix_vg)

   180

	return NULL;

   181

  else if (this->is_variable_prefix_null()) {

   182

	vartype = search_varfb_instance_type->get_vartype(symbol);

   183

	if (wanted_variablegeneration == fparam_output_vg) {

   184

      if (vartype == search_var_instance_decl_c::external_vt)

   185

    	s4o.print(GET_EXTERNAL);

   186

      else

   187

    	s4o.print("&");

   188

      s4o.print("(");

   189

      generate_c_base_c::visit(symbol);

   190

      s4o.print(")");

   191

    }

   192

    else {

   193

      if (vartype == search_var_instance_decl_c::external_vt) {

   194

        s4o.print(GET_EXTERNAL);

   195

        s4o.print("(");

   196

        generate_c_base_c::visit(symbol);

   197

        s4o.print(")");

   198

      }

   199

      else

   200

    	generate_c_base_c::visit(symbol);

   201

    }

   202

  }

   203

  else {

   204

    switch (wanted_variablegeneration) {

   205

      case expression_vg:

   206

    	vartype = search_varfb_instance_type->get_vartype(symbol);

   207

    	if (vartype == search_var_instance_decl_c::external_vt)

   208

    	  s4o.print(GET_EXTERNAL);

   209

    	else if (vartype == search_var_instance_decl_c::located_vt)

   210

		  s4o.print(GET_LOCATED);

   211

	    else

   212

		  s4o.print(GET_VAR);

   213

	    s4o.print("(");

   214

	    generate_c_base_c::visit(symbol);

   215

        s4o.print(")");

   216

		break;

   217

      case fparam_output_vg:

   218

    	vartype = search_varfb_instance_type->get_vartype(symbol);

   219

    	if (vartype == search_var_instance_decl_c::external_vt)

   220

          s4o.print(GET_EXTERNAL_BY_REF);

   221

        else if (vartype == search_var_instance_decl_c::located_vt)

   222

          s4o.print(GET_LOCATED_BY_REF);

   223

        else

   224

          s4o.print(GET_VAR_BY_REF);

   225

        s4o.print("(");

   226

        generate_c_base_c::visit(symbol);

   227

        s4o.print(")");

   228

        break;

   229

      default:

   230

        generate_c_base_c::visit(symbol);

   231

        break;

   232

	}

   233

  }

   234

  return NULL;

   235

}

   236

   237

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

   238

/* B.1.4.1   Directly Represented Variables */

   239

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

   240

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

   241

void *visit(direct_variable_c *symbol) {

   242

  TRACE("direct_variable_c");

   243

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

   244

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

   245

  if (this->is_variable_prefix_null()) {

   246

    if (wanted_variablegeneration != fparam_output_vg)

   247

	  s4o.print("*(");

   248

  }

   249

  else {

   250

    switch (wanted_variablegeneration) {

   251

      case expression_vg:

   252

  	    s4o.print(GET_LOCATED);

   253

  	    s4o.print("(");

   254

  	    break;

   255

      case fparam_output_vg:

   256

        s4o.print(GET_LOCATED_BY_REF);

   257

        s4o.print("(");

   258

        break;

   259

      default:

   260

        break;

   261

    }

   262

  }

   263

  this->print_variable_prefix();

   264

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

   265

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

   266

	  wanted_variablegeneration != assignment_vg)

   267

    s4o.print(")");

   268

  return NULL;

   269

}

   270

   271

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

   272

/* B.1.4.2   Multi-element Variables */

   273

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

   274

   275

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   276

void *visit(structured_variable_c *symbol) {

   277

  TRACE("structured_variable_c");

   278

  switch (wanted_variablegeneration) {

   279

    case complextype_base_vg:

   280

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

   281

      break;

   282

    case complextype_suffix_vg:

   283

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

   284

      s4o.print(".");

   285

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

   286

      break;

   287

    default:

   288

      if (this->is_variable_prefix_null()) {

   289

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

   290

    	s4o.print(".");

   291

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

   292

      }

   293

      else

   294

    	print_getter(symbol);

   295

      break;

   296

  }

   297

  return NULL;

   298

}

   299

   300

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

   301

//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   302

void *visit(array_variable_c *symbol) {

   303

  switch (wanted_variablegeneration) {

   304

    case complextype_base_vg:

   305

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

   306

      break;

   307

    case complextype_suffix_vg:

   308

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

   309

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

   310

      if (current_array_type != NULL) {

   311

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

   312

        current_array_type = NULL;

   313

      }

   314

      break;

   315

    default:

   316

      if (this->is_variable_prefix_null()) {

   317

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

   318

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

   319

    	if (current_array_type != NULL) {

   320

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

   321

    	  current_array_type = NULL;

   322

    	}

   323

      }

   324

      else

   325

    	print_getter(symbol);

   326

      break;

   327

  }

   328

  return NULL;

   329

}

   330

   331

/* subscript_list ',' subscript */

   332

void *visit(subscript_list_c *symbol) {

   333

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

   334

    s4o.print("[__");

   335

    current_array_type->accept(*this);

   336

    s4o.print("_TRANSIDX");

   337

    print_integer(i);

   338

    s4o.print("(");

   339

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

   340

    s4o.print(")]");

   341

  }

   342

  return NULL;

   343

}

   344

   345

   346

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

   347

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

   348

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

   349

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

   350

/* B 3.1 - Expressions */

   351

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

   352

void *visit(or_expression_c *symbol) {

   353

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

   354

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

   355

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

   356

      ERROR;

   357

  if (search_expression_type->is_bool_type(left_type))

   358

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

   359

  if (search_expression_type->is_binary_type(left_type))

   360

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

   361

  ERROR;

   362

  return NULL;

   363

}

   364

   365

void *visit(xor_expression_c *symbol) {

   366

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

   367

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

   368

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

   369

      ERROR;

   370

  if (search_expression_type->is_bool_type(left_type)) {

   371

    s4o.print("(");

   372

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

   373

    s4o.print(" && !");

   374

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

   375

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

   376

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

   377

    s4o.print(" && ");

   378

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

   379

    s4o.print(")");

   380

    return NULL;

   381

  }

   382

  if (search_expression_type->is_binary_type(left_type))

   383

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

   384

  ERROR;

   385

  return NULL;

   386

}

   387

   388

void *visit(and_expression_c *symbol) {

   389

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

   390

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

   391

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

   392

      ERROR;

   393

  if (search_expression_type->is_bool_type(left_type))

   394

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

   395

  if (search_expression_type->is_binary_type(left_type))

   396

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

   397

  ERROR;

   398

  return NULL;

   399

}

   400

   401

void *visit(equ_expression_c *symbol) {

   402

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

   403

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

   404

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

   405

      ERROR;

   406

  if (search_expression_type->is_time_type(left_type) ||

   407

      search_expression_type->is_string_type(left_type))

   408

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

   409

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

   410

}

   411

   412

void *visit(notequ_expression_c *symbol) {

   413

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

   414

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

   415

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

   416

      ERROR;

   417

  if (search_expression_type->is_time_type(left_type) ||

   418

      search_expression_type->is_string_type(left_type))

   419

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

   420

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

   421

}

   422

   423

void *visit(lt_expression_c *symbol) {

   424

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

   425

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

   426

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

   427

      ERROR;

   428

  if (search_expression_type->is_time_type(left_type) ||

   429

      search_expression_type->is_string_type(left_type))

   430

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

   431

  if (!search_base_type.type_is_enumerated(left_type))

   432

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

   433

  ERROR;

   434

  return NULL;

   435

}

   436

   437

void *visit(gt_expression_c *symbol) {

   438

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

   439

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

   440

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

   441

      ERROR;

   442

  if (search_expression_type->is_time_type(left_type) ||

   443

      search_expression_type->is_string_type(left_type))

   444

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

   445

  if (!search_base_type.type_is_enumerated(left_type))

   446

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

   447

  ERROR;

   448

  return NULL;

   449

}

   450

   451

void *visit(le_expression_c *symbol) {

   452

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

   453

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

   454

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

   455

      ERROR;

   456

  if (search_expression_type->is_time_type(left_type) ||

   457

      search_expression_type->is_string_type(left_type))

   458

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

   459

  if (!search_base_type.type_is_enumerated(left_type))

   460

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

   461

  ERROR;

   462

  return NULL;

   463

}

   464

   465

void *visit(ge_expression_c *symbol) {

   466

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

   467

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

   468

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

   469

      ERROR;

   470

  if (search_expression_type->is_time_type(left_type) ||

   471

      search_expression_type->is_string_type(left_type))

   472

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

   473

  if (!search_base_type.type_is_enumerated(left_type))

   474

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

   475

  ERROR;

   476

  return NULL;

   477

}

   478

   479

void *visit(add_expression_c *symbol) {

   480

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

   481

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

   482

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

   483

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

   484

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

   485

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

   486

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

   487

      ERROR;

   488

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

   489

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

   490

  ERROR;

   491

  return NULL;

   492

}

   493

   494

void *visit(sub_expression_c *symbol) {

   495

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

   496

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

   497

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

   498

      (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_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(tod_type_name_c) && typeid(*right_type) == typeid(tod_type_name_c)) ||

   501

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

   502

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

   503

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

   504

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

   505

      ERROR;

   506

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

   507

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