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

    50

  private:

    51

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

    52

     * by searching through the declarations of the variables currently

    53

     * in scope.

    54

     * This class does just that...

    55

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

    56

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

    57

     * This object instance will then later be called while the

    58

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

    59

     *

    60

     * Note that functions cannot contain calls to function blocks,

    61

     * so we do not create an object instance when handling

    62

     * a function declaration.

    63

     */

    64

    search_fb_instance_decl_c *search_fb_instance_decl;

    65

    66

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

    67

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

    68

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

    69

     * or function currently being processed.

    70

     * The following object does just that...

    71

     * This object instance will then later be called while the

    72

     * remaining st code is being handled.

    73

     */

    74

    search_expression_type_c *search_expression_type;

    75

    76

    search_varfb_instance_type_c *search_varfb_instance_type;

    77

    78

    search_base_type_c search_base_type;

    79

    80

    symbol_c* current_array_type;

    81

    86

    87

  public:

    89

    : generate_c_typedecl_c(s4o_ptr) {

    90

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

    91

      search_expression_type = new search_expression_type_c(scope);

    92

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

    93

      this->set_variable_prefix(variable_prefix);

    94

      current_array_type = NULL;

    98

    }

    99

   100

    virtual ~generate_c_st_c(void) {

   101

      delete search_fb_instance_decl;

   102

      delete search_expression_type;

   103

      delete search_varfb_instance_type;

   104

    }

   105

   106

   107

  public:

   108

    void generate(statement_list_c *stl) {

   109

      stl->accept(*this);

   110

    }

   111

   112

  private:

   113

   114

   115

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

   116

/* B 1.4 - Variables */

   117

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

   118

void *visit(symbolic_variable_c *symbol) {

   119

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

   143

  }

   144

  else {

   185

  }

   186

  return NULL;

   187

}

   188

   189

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

   190

/* B.1.4.1   Directly Represented Variables */

   191

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

   192

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

   193

void *visit(direct_variable_c *symbol) {

   194

  TRACE("direct_variable_c");

   195

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

   196

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

   214

  }

   215

  this->print_variable_prefix();

   216

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

   219

    s4o.print(")");

   220

  return NULL;

   221

}

   222

   223

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

   224

/* B.1.4.2   Multi-element Variables */

   225

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

   226

   227

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

   228

//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   229

void *visit(array_variable_c *symbol) {

   230

  current_array_type = search_varfb_instance_type->get_type(symbol->subscripted_variable, false);

   231

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

   232

  if (current_array_type != NULL) {

   233

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

   234

    current_array_type = NULL;

   235

  }

   236

  return NULL;

   237

}

   238

   239

/* subscript_list ',' subscript */

   240

void *visit(subscript_list_c *symbol) {

   241

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

   242

    s4o.print("[__");

   243

    current_array_type->accept(*this);

   244

    s4o.print("_TRANSIDX");

   245

    print_integer(i);

   246

    s4o.print("(");

   247

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

   248

    s4o.print(")]");

   249

  }

   250

  return NULL;

   251

}

   252

   253

   254

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

   255

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

   256

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

   257

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

   258

/* B 3.1 - Expressions */

   259

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

   260

void *visit(or_expression_c *symbol) {

   261

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

   262

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

   263

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

   264

      ERROR;

   265

  if (search_expression_type->is_bool_type(left_type))

   266

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

   267

  if (search_expression_type->is_binary_type(left_type))

   268

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

   269

  ERROR;

   270

  return NULL;

   271

}

   272

   273

void *visit(xor_expression_c *symbol) {

   274

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

   275

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

   276

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

   277

      ERROR;

   278

  if (search_expression_type->is_bool_type(left_type)) {

   279

    s4o.print("(");

   280

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

   281

    s4o.print(" && !");

   282

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

   283

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

   284

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

   285

    s4o.print(" && ");

   286

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

   287

    s4o.print(")");

   288

    return NULL;

   289

  }

   290

  if (search_expression_type->is_binary_type(left_type))

   291

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

   292

  ERROR;

   293

  return NULL;

   294

}

   295

   296

void *visit(and_expression_c *symbol) {

   297

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

   298

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

   299

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

   300

      ERROR;

   301

  if (search_expression_type->is_bool_type(left_type))

   302

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

   303

  if (search_expression_type->is_binary_type(left_type))

   304

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

   305

  ERROR;

   306

  return NULL;

   307

}

   308

   309

void *visit(equ_expression_c *symbol) {

   310

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

   311

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

   312

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

   313

      ERROR;

   314

  if (search_expression_type->is_time_type(left_type) ||

   315

      search_expression_type->is_string_type(left_type))

   316

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

   317

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

   318

}

   319

   320

void *visit(notequ_expression_c *symbol) {

   321

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

   322

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

   323

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

   324

      ERROR;

   325

  if (search_expression_type->is_time_type(left_type) ||

   326

      search_expression_type->is_string_type(left_type))

   327

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

   328

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

   329

}

   330

   331

void *visit(lt_expression_c *symbol) {

   332

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

   333

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

   334

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

   335

      ERROR;

   336

  if (search_expression_type->is_time_type(left_type) ||

   337

      search_expression_type->is_string_type(left_type))

   338

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

   339

  if (!search_base_type.type_is_enumerated(left_type))

   340

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

   341

  ERROR;

   342

  return NULL;

   343

}

   344

   345

void *visit(gt_expression_c *symbol) {

   346

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

   347

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

   348

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

   349

      ERROR;

   350

  if (search_expression_type->is_time_type(left_type) ||

   351

      search_expression_type->is_string_type(left_type))

   352

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

   353

  if (!search_base_type.type_is_enumerated(left_type))

   354

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

   355

  ERROR;

   356

  return NULL;

   357

}

   358

   359

void *visit(le_expression_c *symbol) {

   360

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

   361

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

   362

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

   363

      ERROR;

   364

  if (search_expression_type->is_time_type(left_type) ||

   365

      search_expression_type->is_string_type(left_type))

   366

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

   367

  if (!search_base_type.type_is_enumerated(left_type))

   368

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

   369

  ERROR;

   370

  return NULL;

   371

}

   372

   373

void *visit(ge_expression_c *symbol) {

   374

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

   375

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

   376

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

   377

      ERROR;

   378

  if (search_expression_type->is_time_type(left_type) ||

   379

      search_expression_type->is_string_type(left_type))

   380

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

   381

  if (!search_base_type.type_is_enumerated(left_type))

   382

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

   383

  ERROR;

   384

  return NULL;

   385

}

   386

   387

void *visit(add_expression_c *symbol) {

   388

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

   389

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

   390

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

   391

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

   392

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

   393

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

   394

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

   395

      ERROR;

   396

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

   397

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

   398

  ERROR;

   399

  return NULL;

   400

}

   401

   402

void *visit(sub_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 ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||

   406

      (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c)) ||

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

      ERROR;

   414

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

   415

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

   416

  ERROR;

   417

  return NULL;

   418

}

   419

   420

void *visit(mul_expression_c *symbol) {

   421

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

   422

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

   423

  if ((typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_integer_type(right_type)) ||

   424

      (typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_real_type(right_type)))

   425

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

   426

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

   427

      ERROR;

   428

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

   429

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

   430

  ERROR;

   431

  return NULL;

   432

}

   433

   434

void *visit(div_expression_c *symbol) {

   435

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

   436

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

   437

  if ((typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_integer_type(right_type)) ||

   438

      (typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_real_type(right_type)))

   439

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

   440

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

   441

      ERROR;

   442

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

   443

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

   444

  ERROR;

   445

  return NULL;

   446

}

   447

   448

void *visit(mod_expression_c *symbol) {

   449

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

   450

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

   451

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

   452

      ERROR;

   453

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

   454

    s4o.print("((");

   455

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

   456

    s4o.print(" == 0)?0:");

   457

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

   458

    s4o.print(")");

   459

    return NULL;

   460

  }

   461

  ERROR;

   462

  return NULL;

   463

}

   464

   465

/* TODO: power expression... */

   466

void *visit(power_expression_c *symbol) {ERROR; return print_binary_expression(symbol->l_exp, symbol->r_exp, " ** ");}

   467

void *visit(neg_expression_c *symbol) {

   468

  symbol_c *exp_type = search_expression_type->get_type(symbol->exp);

   469

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

   470

    return print_unary_expression(symbol->exp, " -");

   471

  ERROR;

   472

  return NULL;

   473

}

   474

   475

void *visit(not_expression_c *symbol) {

   476

  symbol_c *exp_type = search_expression_type->get_type(symbol->exp);

   477

  if (search_expression_type->is_binary_type(exp_type))

   478

    return print_unary_expression(symbol->exp, search_expression_type->is_bool_type(exp_type)?"!":"~");

   479

  ERROR;

   480

  return NULL;

   481

}

   482

   483

void *visit(function_invocation_c *symbol) {

   484

  symbol_c* function_type_prefix = NULL;

   485

  symbol_c* function_name = NULL;

   486

  symbol_c* function_type_suffix = NULL;

   488

   489

  symbol_c *parameter_assignment_list = NULL;

   490

  if (NULL != symbol->   formal_param_list) parameter_assignment_list = symbol->   formal_param_list;

   491

  if (NULL != symbol->nonformal_param_list) parameter_assignment_list = symbol->nonformal_param_list;

   492

  if (NULL == parameter_assignment_list) ERROR;

   493

   494

  function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);

   495

  if (f_decl == function_symtable.end_value()) {

   496

    /* The function called is not in the symtable, so we test if it is a

   497

     * standard function defined in standard */

   498

   499

    function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);

   500

    if (current_function_type == function_none) ERROR;

   501

   502

    symbol_c *function_return_type = search_expression_type->get_type(symbol);

   503

   504

    function_call_param_iterator_c function_call_param_iterator(symbol);

   505

   506

    int nb_param = ((list_c *)parameter_assignment_list)->n;

   507

   508

    identifier_c en_param_name("EN");

   509

    /* Get the value from EN param */

   510

    symbol_c *EN_param_value = function_call_param_iterator.search_f(&en_param_name);

   511

    if (EN_param_value == NULL)