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

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

   145

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

   146

    if (variable != NULL) {

   147

      s4o.print(SET_EXTERNAL);

   148

      s4o.print("(");

   149

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

   150

      s4o.print(",");

   151

    }

   152

    else {

   153

      s4o.print(SET_COMPLEX_EXTERNAL);

   154

      s4o.print("(");

   155

    }

   156

  }

   157

  else {

   158

    if (vartype == search_var_instance_decl_c::located_vt)

   159

      s4o.print(SET_LOCATED);

   160

    else

   161

      s4o.print(SET_VAR);

   162

    s4o.print("(");

   163

  }

   164

   165

  if (fb_symbol != NULL) {

   166

    print_variable_prefix();

   167

    fb_symbol->accept(*this);

   168

    s4o.print(".");

   169

  }

   170

  else

   171

    wanted_variablegeneration = complextype_base_vg;

   172

  symbol->accept(*this);

   173

  s4o.print(",");

   174

  wanted_variablegeneration = expression_vg;

   175

  print_check_function(type, value, fb_value);

   176

  if (search_varfb_instance_type->type_is_complex()) {

   177

    s4o.print(",");

   178

    wanted_variablegeneration = complextype_suffix_vg;

   179

    symbol->accept(*this);

   180

  }

   181

  s4o.print(")");

   182

  wanted_variablegeneration = expression_vg;

   183

  return NULL;

   184

}

   185

   186

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

   187

/* B 1.4 - Variables */

   188

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

   189

void *visit(symbolic_variable_c *symbol) {

   190

  unsigned int vartype;

   191

  if (wanted_variablegeneration == complextype_base_vg)

   192

	generate_c_base_c::visit(symbol);

   193

  else if (wanted_variablegeneration == complextype_suffix_vg)

   194

	return NULL;

   195

  else if (this->is_variable_prefix_null()) {

   196

	vartype = search_varfb_instance_type->get_vartype(symbol);

   197

	if (wanted_variablegeneration == fparam_output_vg) {

   198

      if (vartype == search_var_instance_decl_c::external_vt)

   199

    	s4o.print(GET_EXTERNAL);

   200

      else

   201

    	s4o.print("&");

   202

      s4o.print("(");

   203

      generate_c_base_c::visit(symbol);

   204

      s4o.print(")");

   205

    }

   206

    else {

   207

      if (vartype == search_var_instance_decl_c::external_vt) {

   208

        s4o.print(GET_EXTERNAL);

   209

        s4o.print("(");

   210

        generate_c_base_c::visit(symbol);

   211

        s4o.print(")");

   212

      }

   213

      else

   214

    	generate_c_base_c::visit(symbol);

   215

    }

   216

  }

   217

  else {

   218

    switch (wanted_variablegeneration) {

   219

      case expression_vg:

   220

    	vartype = search_varfb_instance_type->get_vartype(symbol);

   221

    	if (vartype == search_var_instance_decl_c::external_vt)

   222

    	  s4o.print(GET_EXTERNAL);

   223

    	else if (vartype == search_var_instance_decl_c::located_vt)

   224

		  s4o.print(GET_LOCATED);

   225

	    else

   226

		  s4o.print(GET_VAR);

   227

	    s4o.print("(");

   228

	    generate_c_base_c::visit(symbol);

   229

        s4o.print(")");

   230

		break;

   231

      case fparam_output_vg:

   232

    	vartype = search_varfb_instance_type->get_vartype(symbol);

   233

    	if (vartype == search_var_instance_decl_c::external_vt)

   234

          s4o.print(GET_EXTERNAL_BY_REF);

   235

        else if (vartype == search_var_instance_decl_c::located_vt)

   236

          s4o.print(GET_LOCATED_BY_REF);

   237

        else

   238

          s4o.print(GET_VAR_BY_REF);

   239

        s4o.print("(");

   240

        generate_c_base_c::visit(symbol);

   241

        s4o.print(")");

   242

        break;

   243

      default:

   244

        generate_c_base_c::visit(symbol);

   245

        break;

   246

	}

   247

  }

   248

  return NULL;

   249

}

   250

   251

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

   252

/* B.1.4.1   Directly Represented Variables */

   253

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

   254

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

   255

void *visit(direct_variable_c *symbol) {

   256

  TRACE("direct_variable_c");

   257

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

   258

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

   259

  if (this->is_variable_prefix_null()) {

   260

    if (wanted_variablegeneration != fparam_output_vg)

   261

	  s4o.print("*(");

   262

  }

   263

  else {

   264

    switch (wanted_variablegeneration) {

   265

      case expression_vg:

   266

  	    s4o.print(GET_LOCATED);

   267

  	    s4o.print("(");

   268

  	    break;

   269

      case fparam_output_vg:

   270

        s4o.print(GET_LOCATED_BY_REF);

   271

        s4o.print("(");

   272

        break;

   273

      default:

   274

        break;

   275

    }

   276

  }

   277

  this->print_variable_prefix();

   278

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

   279

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

   280

	  wanted_variablegeneration != assignment_vg)

   281

    s4o.print(")");

   282

  return NULL;

   283

}

   284

   285

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

   286

/* B.1.4.2   Multi-element Variables */

   287

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

   288

   289

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   290

void *visit(structured_variable_c *symbol) {

   291

  TRACE("structured_variable_c");

   292

  switch (wanted_variablegeneration) {

   293

    case complextype_base_vg:

   294

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

   295

      break;

   296

    case complextype_suffix_vg:

   297

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

   298

      s4o.print(".");

   299

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

   300

      break;

   301

    default:

   302

      if (this->is_variable_prefix_null()) {

   303

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

   304

    	s4o.print(".");

   305

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

   306

      }

   307

      else

   308

    	print_getter(symbol);

   309

      break;

   310

  }

   311

  return NULL;

   312

}

   313

   314

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

   315

//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   316

void *visit(array_variable_c *symbol) {

   317

  switch (wanted_variablegeneration) {

   318

    case complextype_base_vg:

   319

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

   320

      break;

   321

    case complextype_suffix_vg:

   322

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

   323

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

   324

      if (current_array_type != NULL) {

   325

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

   326

        current_array_type = NULL;

   327

      }

   328

      break;

   329

    default:

   330

      if (this->is_variable_prefix_null()) {

   331

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

   332

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

   333

    	if (current_array_type != NULL) {

   334

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

   335

    	  current_array_type = NULL;

   336

    	}

   337

      }

   338

      else

   339

    	print_getter(symbol);

   340

      break;

   341

  }

   342

  return NULL;

   343

}

   344

   345

/* subscript_list ',' subscript */

   346

void *visit(subscript_list_c *symbol) {

   347

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

   348

    s4o.print("[__");

   349

    current_array_type->accept(*this);

   350

    s4o.print("_TRANSIDX");

   351

    print_integer(i);

   352

    s4o.print("(");

   353

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

   354

    s4o.print(")]");

   355

  }

   356

  return NULL;

   357

}

   358

   359

   360

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

   361

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

   362

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

   363

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

   364

/* B 3.1 - Expressions */

   365

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

   366

void *visit(or_expression_c *symbol) {

   367

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

   368

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

   369

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

   370

      ERROR;

   371

  if (search_expression_type->is_bool_type(left_type))

   372

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

   373

  if (search_expression_type->is_binary_type(left_type))

   374

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

   375

  ERROR;

   376

  return NULL;

   377

}

   378

   379

void *visit(xor_expression_c *symbol) {

   380

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

   381

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

   382

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

   383

      ERROR;

   384

  if (search_expression_type->is_bool_type(left_type)) {

   385

    s4o.print("(");

   386

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

   387

    s4o.print(" && !");

   388

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

   389

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

   390

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

   391

    s4o.print(" && ");

   392

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

   393

    s4o.print(")");

   394

    return NULL;

   395

  }

   396

  if (search_expression_type->is_binary_type(left_type))

   397

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

   398

  ERROR;

   399

  return NULL;

   400

}

   401

   402

void *visit(and_expression_c *symbol) {

   403

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

   404

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

   405

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

   406

      ERROR;

   407

  if (search_expression_type->is_bool_type(left_type))

   408

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

   409

  if (search_expression_type->is_binary_type(left_type))

   410

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

   411

  ERROR;

   412

  return NULL;

   413

}

   414

   415

void *visit(equ_expression_c *symbol) {

   416

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

   417

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

   418

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

   419

      ERROR;

   420

  if (search_expression_type->is_time_type(left_type) ||

   421

      search_expression_type->is_string_type(left_type))

   422

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

   423

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

   424

}

   425

   426

void *visit(notequ_expression_c *symbol) {

   427

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

   428

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

   429

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

   430

      ERROR;

   431

  if (search_expression_type->is_time_type(left_type) ||

   432

      search_expression_type->is_string_type(left_type))

   433

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

   434

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

   435

}

   436

   437

void *visit(lt_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("__lt_", 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(gt_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("__gt_", 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(le_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("__le_", 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(ge_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 (!search_expression_type->is_same_type(left_type, right_type))

   483

      ERROR;

   484

  if (search_expression_type->is_time_type(left_type) ||

   485

      search_expression_type->is_string_type(left_type))

   486

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

   487

  if (!search_base_type.type_is_enumerated(left_type))

   488

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

   489

  ERROR;

   490

  return NULL;

   491

}

   492

   493

void *visit(add_expression_c *symbol) {

   494

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

   495

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

   496

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

   497

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

   498

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

   499

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

   500

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

   501

      ERROR;

   502

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

   503

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

   504

  ERROR;

   505

  return NULL;

   506

}